diff --git a/packages/native/src/lib/ElementAssertion.ts b/packages/native/src/lib/ElementAssertion.ts
index f30d78bc..f322b50d 100644
--- a/packages/native/src/lib/ElementAssertion.ts
+++ b/packages/native/src/lib/ElementAssertion.ts
@@ -1,9 +1,12 @@
 import { Assertion, AssertionError } from "@assertive-ts/core";
 import { get } from "dot-prop-immutable";
-import { Children } from "react";
 import { ReactTestInstance } from "react-test-renderer";
 
-import { instanceToString } from "./helpers/helpers";
+import { isAncestorDisabled, isElementDisabled, isAncestorNotVisible, isElementVisible } from "./helpers/accesibility";
+import { getFlattenedStyle, styleToString } from "./helpers/styles";
+import { getTextContent, textMatches } from "./helpers/text";
+import { AssertiveStyle, TestableTextMatcher } from "./helpers/types";
+import { isEmpty, instanceToString, isElementContained } from "./helpers/utils";
 
 export class ElementAssertion extends Assertion<ReactTestInstance> {
   public constructor(actual: ReactTestInstance) {
@@ -35,7 +38,7 @@ export class ElementAssertion extends Assertion<ReactTestInstance> {
     });
 
     return this.execute({
-      assertWhen: this.isElementDisabled(this.actual) || this.isAncestorDisabled(this.actual),
+      assertWhen: isElementDisabled(this.actual) || isAncestorDisabled(this.actual),
       error,
       invertedError,
     });
@@ -61,7 +64,7 @@ export class ElementAssertion extends Assertion<ReactTestInstance> {
     });
 
     return this.execute({
-      assertWhen: !this.isElementDisabled(this.actual) && !this.isAncestorDisabled(this.actual),
+      assertWhen: !isElementDisabled(this.actual) && !isAncestorDisabled(this.actual),
       error,
       invertedError,
     });
@@ -88,7 +91,7 @@ export class ElementAssertion extends Assertion<ReactTestInstance> {
     });
 
     return this.execute({
-      assertWhen: Children.count(this.actual.props.children) === 0,
+      assertWhen: isEmpty(this.actual.children),
       error,
       invertedError,
     });
@@ -115,49 +118,152 @@ export class ElementAssertion extends Assertion<ReactTestInstance> {
     });
 
     return this.execute({
-      assertWhen: this.isElementVisible(this.actual) && this.isAncestorVisible(this.actual),
+      assertWhen: isElementVisible(this.actual) && !isAncestorNotVisible(this.actual),
       error,
       invertedError,
     });
   }
 
-  private isElementDisabled(element: ReactTestInstance): boolean {
-    const { type } = element;
-    const elementType = type.toString();
-    if (elementType === "TextInput" && element?.props?.editable === false) {
-      return true;
-    }
-
-    return (
-        get(element, "props.aria-disabled")
-        || get(element, "props.disabled", false)
-        || get(element, "props.accessibilityState.disabled", false)
-        || get<ReactTestInstance, string[]>(element, "props.accessibilityStates", []).includes("disabled")
-    );
+  /**
+   * Check if an element is contained within another element.
+   *
+   * @example
+   * ```
+   * expect(parent).toContainElement(child);
+   * ```
+   *
+   * @param element - The element to check for.
+   * @returns the assertion instance
+   */
+  public toContainElement(element: ReactTestInstance): this {
+    const error = new AssertionError({
+      actual: this.actual,
+      message: `Expected element ${this.toString()} to contain element ${instanceToString(element)}.`,
+    });
+    const invertedError = new AssertionError({
+      actual: this.actual,
+      message: `Expected element ${this.toString()} NOT to contain element ${instanceToString(element)}.`,
+    });
+
+    return this.execute({
+      assertWhen: isElementContained(this.actual, element),
+      error,
+      invertedError,
+    });
   }
 
-  private isAncestorDisabled(element: ReactTestInstance): boolean {
-    const { parent } = element;
-    return parent !== null && (this.isElementDisabled(element) || this.isAncestorDisabled(parent));
+  /**
+   * Check if the element has a specific property or a specific property value.
+   *
+   * @example
+   * ```
+   * expect(element).toHaveProp("propName");
+   * expect(element).toHaveProp("propName", "propValue");
+   * ```
+   *
+   * @param propName - The name of the prop to check for.
+   * @param value - The value of the prop to check for.
+   * @returns the assertion instance
+   */
+  public toHaveProp(propName: string, value?: unknown): this {
+    const propValue: unknown = get(this.actual, `props.${propName}`, undefined);
+    const hasProp = propValue !== undefined;
+    const isPropEqual = value === undefined || propValue === value;
+
+    const errorMessage = value === undefined
+      ? `Expected element ${this.toString()} to have prop '${propName}'.`
+      : `Expected element ${this.toString()} to have prop '${propName}' with value '${String(value)}'.`;
+
+    const invertedErrorMessage = value === undefined
+      ? `Expected element ${this.toString()} NOT to have prop '${propName}'.`
+      : `Expected element ${this.toString()} NOT to have prop '${propName}' with value '${String(value)}'.`;
+
+    const error = new AssertionError({ actual: this.actual, message: errorMessage });
+    const invertedError = new AssertionError({ actual: this.actual, message: invertedErrorMessage });
+
+    return this.execute({
+      assertWhen: hasProp && isPropEqual,
+      error,
+      invertedError,
+    });
   }
 
-  private isElementVisible(element: ReactTestInstance): boolean {
-    const { type } = element;
+  /**
+   * Asserts that a component has the specified style(s) applied.
+   *
+   * This method supports both single style objects and arrays of style objects.
+   * It checks if all specified style properties match on the target element.
+   *
+   * @example
+   * ```
+   * expect(element).toHaveStyle({ backgroundColor: "red" });
+   * expect(element).toHaveStyle([{ backgroundColor: "red" }]);
+   * ```
+   *
+   * @param style - A style object to check for.
+   * @returns the assertion instance
+   */
+  public toHaveStyle(style: AssertiveStyle): this {
+    const stylesOnElement: AssertiveStyle = get(this.actual, "props.style", {});
+
+    const flattenedElementStyle = getFlattenedStyle(stylesOnElement);
+    const flattenedStyle = getFlattenedStyle(style);
+
+    const hasStyle = Object.keys(flattenedStyle)
+      .every(key => flattenedElementStyle[key] === flattenedStyle[key]);
+
+    const error = new AssertionError({
+      actual: this.actual,
+      message: `Expected element ${this.toString()} to have style: \n${styleToString(flattenedStyle)}`,
+    });
 
-    if (type.toString() === "Modal") {
-      return Boolean(element.props?.visible);
-    }
+    const invertedError = new AssertionError({
+      actual: this.actual,
+      message: `Expected element ${this.toString()} NOT to have style: \n${styleToString(flattenedStyle)}`,
+    });
 
-    return (
-      get(element, "props.style.display") !== "none"
-      && get(element, "props.style.opacity") !== 0
-      && get(element, "props.accessibilityElementsHidden") !== true
-      && get(element, "props.importantForAccessibility") !== "no-hide-descendants"
-    );
+    return this.execute({
+      assertWhen: hasStyle,
+      error,
+      invertedError,
+    });
   }
 
-  private isAncestorVisible(element: ReactTestInstance): boolean {
-    const { parent } = element;
-    return parent === null || (this.isElementVisible(parent) && this.isAncestorVisible(parent));
+  /**
+   * Check if the element has text content matching the provided string,
+   * RegExp, or function.
+   *
+   * @example
+   * ```
+   * expect(element).toHaveTextContent("Hello World");
+   * expect(element).toHaveTextContent(/Hello/);
+   * expect(element).toHaveTextContent(text => text.startsWith("Hello"));
+   * ```
+   *
+   * @param text - The text to check for.
+   * @returns the assertion instance
+   */
+  public toHaveTextContent(text: TestableTextMatcher): this {
+    const actualTextContent = getTextContent(this.actual);
+    const matchesText = textMatches(actualTextContent, text);
+
+    const error = new AssertionError({
+      actual: this.actual,
+      message: `Expected element ${this.toString()} to have text content matching '` +
+        `${text.toString()}'.`,
+    });
+
+    const invertedError = new AssertionError({
+      actual: this.actual,
+      message:
+        `Expected element ${this.toString()} NOT to have text content matching '` +
+        `${text.toString()}'.`,
+    });
+
+    return this.execute({
+      assertWhen: matchesText,
+      error,
+      invertedError,
+    });
   }
 }
diff --git a/packages/native/src/lib/helpers/accesibility.ts b/packages/native/src/lib/helpers/accesibility.ts
new file mode 100644
index 00000000..8855c711
--- /dev/null
+++ b/packages/native/src/lib/helpers/accesibility.ts
@@ -0,0 +1,38 @@
+import { get } from "dot-prop-immutable";
+import { ReactTestInstance } from "react-test-renderer";
+
+export function isElementDisabled(element: ReactTestInstance): boolean {
+  const { type } = element;
+  const elementType = type.toString();
+  if (elementType === "TextInput" && element?.props?.editable === false) {
+    return true;
+  }
+  return (
+    get(element, "props.aria-disabled")
+    || get(element, "props.disabled", false)
+    || get(element, "props.accessibilityState.disabled", false)
+    || get<ReactTestInstance, string[]>(element, "props.accessibilityStates", []).includes("disabled")
+  );
+}
+
+export function isAncestorDisabled(element: ReactTestInstance): boolean {
+  const { parent } = element;
+  return parent !== null && (isElementDisabled(element) || isAncestorDisabled(parent));
+}
+export function isElementVisible(element: ReactTestInstance): boolean {
+  const { type } = element;
+  const elementType = type.toString();
+  if (elementType === "Modal" && !element?.props?.visible === true) {
+    return false;
+  }
+  return (
+    get(element, "props.style.display") !== "none"
+    && get(element, "props.style.opacity") !== 0
+    && get(element, "props.accessibilityElementsHidden") !== true
+    && get(element, "props.importantForAccessibility") !== "no-hide-descendants"
+  );
+}
+export function isAncestorNotVisible(element: ReactTestInstance): boolean {
+  const { parent } = element;
+  return parent !== null && (!isElementVisible(element) || isAncestorNotVisible(parent));
+}
diff --git a/packages/native/src/lib/helpers/helpers.ts b/packages/native/src/lib/helpers/helpers.ts
deleted file mode 100644
index 631395c9..00000000
--- a/packages/native/src/lib/helpers/helpers.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { ReactTestInstance } from "react-test-renderer";
-
-/**
- * Converts a ReactTestInstance to a string representation.
- *
- * @param instance The ReactTestInstance to convert.
- * @returns A string representation of the instance.
- */
-export function instanceToString(instance: ReactTestInstance | null): string {
-  if (instance === null) {
-    return "null";
-  }
-
-  return `<${instance.type.toString()} ... />`;
-}
diff --git a/packages/native/src/lib/helpers/styles.ts b/packages/native/src/lib/helpers/styles.ts
new file mode 100644
index 00000000..3b14ef7d
--- /dev/null
+++ b/packages/native/src/lib/helpers/styles.ts
@@ -0,0 +1,13 @@
+import { StyleSheet } from "react-native";
+
+import { AssertiveStyle, StyleObject } from "./types";
+
+export function getFlattenedStyle(style: AssertiveStyle): StyleObject {
+    const flattenedStyle = StyleSheet.flatten(style);
+    return flattenedStyle ? (flattenedStyle as StyleObject) : {};
+}
+
+export function styleToString(flattenedStyle: StyleObject): string {
+  const styleEntries = Object.entries(flattenedStyle);
+  return styleEntries.map(([key, value]) => `\t- ${key}: ${String(value)};`).join("\n");
+}
diff --git a/packages/native/src/lib/helpers/text.ts b/packages/native/src/lib/helpers/text.ts
new file mode 100644
index 00000000..6bccbbff
--- /dev/null
+++ b/packages/native/src/lib/helpers/text.ts
@@ -0,0 +1,64 @@
+import { ReactTestInstance } from "react-test-renderer";
+
+import { TestableTextMatcher, TextContent } from "./types";
+
+function collectText (element: TextContent): string[] {
+    if (typeof element === "string") {
+      return [element];
+    }
+
+    if (Array.isArray(element)) {
+      return element.flatMap(child => collectText(child));
+    }
+
+    if (element && (typeof element === "object" && "props" in element)) {
+      const value = element.props?.value as TextContent;
+      if (typeof value === "string") {
+        return [value];
+      }
+
+      const children = (element.props?.children as ReactTestInstance[]) ?? element.children;
+      if (!children) {
+        return [];
+      }
+
+      return Array.isArray(children)
+        ? children.flatMap(collectText)
+        : collectText(children);
+    }
+
+    return [];
+}
+
+export function getTextContent(element: ReactTestInstance): string {
+    if (!element) {
+    return "";
+    }
+    if (typeof element === "string") {
+    return element;
+    }
+    if (typeof element.props?.value === "string") {
+    return element.props.value;
+    }
+
+    return collectText(element).join(" ");
+}
+
+export function textMatches(
+  text: string,
+  matcher: TestableTextMatcher,
+): boolean {
+  if (typeof matcher === "string") {
+    return text.includes(matcher);
+  }
+
+  if (matcher instanceof RegExp) {
+    return matcher.test(text);
+  }
+
+  if (typeof matcher === "function") {
+    return matcher(text);
+  }
+
+  throw new Error("Matcher must be a string, RegExp, or function.");
+}
diff --git a/packages/native/src/lib/helpers/types.ts b/packages/native/src/lib/helpers/types.ts
new file mode 100644
index 00000000..69fad07c
--- /dev/null
+++ b/packages/native/src/lib/helpers/types.ts
@@ -0,0 +1,12 @@
+import { ImageStyle, StyleProp, TextStyle, ViewStyle } from "react-native";
+import { ReactTestInstance } from "react-test-renderer";
+
+type Style = TextStyle | ViewStyle | ImageStyle;
+
+export type AssertiveStyle = StyleProp<Style>;
+
+export type StyleObject = Record<string, unknown>;
+
+export type TestableTextMatcher = string | RegExp | ((text: string) => boolean);
+
+export type TextContent = string | ReactTestInstance | ReactTestInstance[];
diff --git a/packages/native/src/lib/helpers/utils.ts b/packages/native/src/lib/helpers/utils.ts
new file mode 100644
index 00000000..6a24e011
--- /dev/null
+++ b/packages/native/src/lib/helpers/utils.ts
@@ -0,0 +1,33 @@
+import { ReactTestInstance } from "react-test-renderer";
+
+export function isEmpty(value: unknown): boolean {
+  if (!value) {
+    return true;
+  }
+
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  return false;
+}
+
+export function instanceToString(instance: ReactTestInstance | null): string {
+  if (instance === null) {
+    return "null";
+  }
+
+  return `<${instance.type.toString()} ... />`;
+}
+
+export function isElementContained(parentElement: ReactTestInstance, childElement: ReactTestInstance): boolean {
+  if (parentElement === null || childElement === null) {
+    return false;
+  }
+  return (
+      parentElement.findAll(
+          node =>
+              node.type === childElement.type && node.props === childElement.props,
+      ).length > 0
+  );
+}
diff --git a/packages/native/test/lib/ElementAssertion.test.tsx b/packages/native/test/lib/ElementAssertion.test.tsx
index 575046da..c4d07651 100644
--- a/packages/native/test/lib/ElementAssertion.test.tsx
+++ b/packages/native/test/lib/ElementAssertion.test.tsx
@@ -1,35 +1,15 @@
 import { AssertionError, expect } from "@assertive-ts/core";
-import { fireEvent, render } from "@testing-library/react-native";
-import { useState, useCallback, ReactElement } from "react";
+import { render } from "@testing-library/react-native";
 import {
   View,
   TextInput,
   Text,
   Modal,
-  Button,
 } from "react-native";
 
 import { ElementAssertion } from "../../src/lib/ElementAssertion";
 
-function SimpleToggleText(): ReactElement {
-  const [isVisible, setIsVisible] = useState(true);
-
-  const handleToggle = useCallback((): void => {
-    setIsVisible(prev => !prev);
-  }, []);
-
-  return (
-    <View>
-      <Text style={{ display: isVisible ? "flex" : "none" }}>
-        {"Toggle me!"}
-      </Text>
-      <Button
-        title="Toggle Text"
-        onPress={handleToggle}
-      />
-    </View>
-  );
-}
+import { ContainElementTestComponent } from "./fixtures/containElementTestComponent";
 
 describe("[Unit] ElementAssertion.test.ts", () => {
   describe(".toBeDisabled", () => {
@@ -152,6 +132,146 @@ describe("[Unit] ElementAssertion.test.ts", () => {
         });
       });
     });
+
+    context("when the element contains 'accessibilityElementsHidden' property", () => {
+      it("returns the assertion instance", () => {
+        const { getByTestId } = render(
+          <View testID="id" accessibilityElementsHidden={false} />,
+        );
+        const test = new ElementAssertion(getByTestId("id"));
+
+        expect(test.toBeVisible()).toBe(test);
+        expect(() => test.not.toBeVisible())
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to be visible.");
+      });
+    });
+
+    context("when the element contains 'importantForAccessibility' property", () => {
+      it("returns the assertion instance", () => {
+        const { getByTestId } = render(
+          <View testID="id" importantForAccessibility={"yes"} />,
+        );
+        const test = new ElementAssertion(getByTestId("id"));
+
+        expect(test.toBeVisible()).toBe(test);
+        expect(() => test.not.toBeVisible())
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to be visible.");
+      });
+    });
+
+    context("when the parent element contains 'opacity' property", () => {
+      context("and parent opacity = 0", () => {
+        const { getByTestId } = render(
+          <View testID="parentId" style={{ opacity: 0 }} >
+            <View testID="childId" style={{ opacity: 1 }} />
+          </View>,
+        );
+
+        const parent = new ElementAssertion(getByTestId("parentId"));
+        const child = new ElementAssertion(getByTestId("childId"));
+
+        it("returns assertion instance for NOT visible elements", () => {
+          expect(parent.not.toBeVisible()).toBeEqual(parent);
+          expect(child.not.toBeVisible()).toBeEqual(child);
+        });
+
+        it("throws an error for visible elements", () => {
+          expect(() => parent.toBeVisible())
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> to be visible.");
+          expect(() => child.toBeVisible())
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> to be visible.");
+        });
+      });
+
+      context("and child opacity = 0", () => {
+        const { getByTestId } = render(
+          <View testID="parentId" style={{ opacity: 1 }} >
+            <View testID="childId" style={{ opacity: 0 }} />
+          </View>,
+        );
+
+        const parent = new ElementAssertion(getByTestId("parentId"));
+        const child = new ElementAssertion(getByTestId("childId"));
+
+        it("returns assertion instance for visible parent and NOT visible child", () => {
+          expect(parent.toBeVisible()).toBeEqual(parent);
+          expect(child.not.toBeVisible()).toBeEqual(child);
+        });
+
+        it("throws an error for NOT visible parent and visible child", () => {
+          expect(() => parent.not.toBeVisible())
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> NOT to be visible.");
+          expect(() => child.toBeVisible())
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> to be visible.");
+        });
+      });
+    });
+  });
+
+  describe (".toContainElement", () => {
+    const element = render(
+      <View testID="grandParentId">
+        <View testID="parentId">
+          <View testID="childId" />
+        </View>
+        <Text testID="textId" />
+      </View>,
+    );
+
+    const container = element.getByTestId("grandParentId");
+    const containerElementAssertion = new ElementAssertion(container);
+    const parent = element.getByTestId("parentId");
+    const parentElementAssertion = new ElementAssertion(parent);
+    const child = element.getByTestId("childId");
+    const text = element.getByTestId("textId");
+    const textElementAssertion = new ElementAssertion(text);
+
+    context("when the element has children", () => {
+      context("and the target element is found in the children's element", () => {
+        it("returns the assertion instance", () => {
+          expect(containerElementAssertion.toContainElement(parent)).toBe(containerElementAssertion);
+          expect(containerElementAssertion.toContainElement(child)).toBe(containerElementAssertion);
+          expect(containerElementAssertion.toContainElement(text)).toBe(containerElementAssertion);
+          expect(parentElementAssertion.toContainElement(child)).toBe(parentElementAssertion);
+        });
+
+        it("throws an error for negative assertion", () => {
+          expect(() => containerElementAssertion.not.toContainElement(parent))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> NOT to contain element <View ... />.");
+          expect(() => containerElementAssertion.not.toContainElement(text))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> NOT to contain element <Text ... />.");
+        });
+      });
+
+      context("and the target element is NOT found in the children's element", () => {
+        it("throws an error", () => {
+          expect(() => parentElementAssertion.toContainElement(text))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> to contain element <Text ... />.");
+        });
+
+        it("returns the assertion instance for negative assertion", () => {
+          expect(parentElementAssertion.not.toContainElement(text)).toBeEqual(parentElementAssertion);
+          expect(parentElementAssertion.not.toContainElement(container)).toBeEqual(parentElementAssertion);
+        });
+      });
+    });
+
+    context("when the element does NOT have children", () => {
+      it("throws an error", () => {
+        expect(() => textElementAssertion.toContainElement(parent))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> to contain element <View ... />.");
+      });
+    });
   });
 
   describe(".toBeEmpty", () => {
@@ -187,10 +307,10 @@ describe("[Unit] ElementAssertion.test.ts", () => {
   describe (".toBeVisible", () => {
     context("when the modal is visible", () => {
       it("returns the assertion instance", () => {
-        const { getByTestId } = render(
+        const element = render(
           <Modal testID="id" visible={true} />,
         );
-        const test = new ElementAssertion(getByTestId("id"));
+        const test = new ElementAssertion(element.getByTestId("id"));
 
         expect(test.toBeVisible()).toBe(test);
         expect(() => test.not.toBeVisible())
@@ -200,43 +320,25 @@ describe("[Unit] ElementAssertion.test.ts", () => {
     });
 
     context("when the element contains 'display' property", () => {
-      context("and display = none", () => {
-        it("throws an error", () => {
-          const { getByText, getByRole } = render(
-            <SimpleToggleText />,
-          );
-          const textElement = new ElementAssertion(getByText("Toggle me!"));
-
-          expect(textElement.toBeVisible()).toBeEqual(textElement);
-
-          const toggleButton = getByRole("button", { name: "Toggle Text" });
-          fireEvent.press(toggleButton);
-
-          expect(textElement.not.toBeVisible()).toBeEqual(textElement);
-        });
-      });
-
-      context("and display = flex", () => {
-        it("returns the assertion instance", () => {
-          const { getByTestId } = render(
-            <View testID="id" style={{ display: "flex" }} />,
-          );
-          const test = new ElementAssertion(getByTestId("id"));
+      it("returns the assertion instance", () => {
+        const element = render(
+          <View testID="id" style={{ display: "flex" }} />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
 
-          expect(test.toBeVisible()).toBe(test);
-          expect(() => test.not.toBeVisible())
-            .toThrowError(AssertionError)
-            .toHaveMessage("Expected element <View ... /> NOT to be visible.");
-        });
+        expect(test.toBeVisible()).toBe(test);
+        expect(() => test.not.toBeVisible())
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to be visible.");
       });
     });
 
     context("when the element contains 'accessibilityElementsHidden' property", () => {
       it("returns the assertion instance", () => {
-        const { getByTestId } = render(
+        const element = render(
           <View testID="id" accessibilityElementsHidden={false} />,
         );
-        const test = new ElementAssertion(getByTestId("id"));
+        const test = new ElementAssertion(element.getByTestId("id"));
 
         expect(test.toBeVisible()).toBe(test);
         expect(() => test.not.toBeVisible())
@@ -247,10 +349,10 @@ describe("[Unit] ElementAssertion.test.ts", () => {
 
     context("when the element contains 'importantForAccessibility' property", () => {
       it("returns the assertion instance", () => {
-        const { getByTestId } = render(
+        const element = render(
           <View testID="id" importantForAccessibility={"yes"} />,
         );
-        const test = new ElementAssertion(getByTestId("id"));
+        const test = new ElementAssertion(element.getByTestId("id"));
 
         expect(test.toBeVisible()).toBe(test);
         expect(() => test.not.toBeVisible())
@@ -260,15 +362,15 @@ describe("[Unit] ElementAssertion.test.ts", () => {
     });
 
     context("when the parent element contains 'opacity' property", () => {
-      context("and parent opacity = 0", () => {
-        const { getByTestId } = render(
+      context("if parent opacity = 0", () => {
+        const element = render(
           <View testID="parentId" style={{ opacity: 0 }} >
             <View testID="childId" style={{ opacity: 1 }} />
           </View>,
         );
 
-        const parent = new ElementAssertion(getByTestId("parentId"));
-        const child = new ElementAssertion(getByTestId("childId"));
+        const parent = new ElementAssertion(element.getByTestId("parentId"));
+        const child = new ElementAssertion(element.getByTestId("childId"));
 
         it("returns assertion instance for NOT visible elements", () => {
           expect(parent.not.toBeVisible()).toBeEqual(parent);
@@ -285,22 +387,22 @@ describe("[Unit] ElementAssertion.test.ts", () => {
         });
       });
 
-      context("and child opacity = 0", () => {
-        const { getByTestId } = render(
+      context("if child opacity = 0", () => {
+        const element = render(
           <View testID="parentId" style={{ opacity: 1 }} >
             <View testID="childId" style={{ opacity: 0 }} />
           </View>,
         );
 
-        const parent = new ElementAssertion(getByTestId("parentId"));
-        const child = new ElementAssertion(getByTestId("childId"));
+        const parent = new ElementAssertion(element.getByTestId("parentId"));
+        const child = new ElementAssertion(element.getByTestId("childId"));
 
-        it("returns assertion instance for visible parent and NOT visible child", () => {
+        it("returns assertion instance for NOT visible elements", () => {
           expect(parent.toBeVisible()).toBeEqual(parent);
           expect(child.not.toBeVisible()).toBeEqual(child);
         });
 
-        it("throws an error for NOT visible parent and visible child", () => {
+        it("throws an error for visible elements", () => {
           expect(() => parent.not.toBeVisible())
             .toThrowError(AssertionError)
             .toHaveMessage("Expected element <View ... /> NOT to be visible.");
@@ -311,4 +413,471 @@ describe("[Unit] ElementAssertion.test.ts", () => {
       });
     });
   });
+
+  describe (".toContainElement", () => {
+    context("when the element has children", () => {
+      context("and the target element is found in the children's element", () => {
+        it("returns the assertion instance", () => {
+          const { getByText, getByTestId } = render(<ContainElementTestComponent />);
+
+          const container = getByTestId("grandParent");
+          const parent = getByTestId("parent");
+          const child = getByText("child");
+          const text = getByText("text");
+
+          const containerElementAssertion = new ElementAssertion(container);
+          const parentElementAssertion = new ElementAssertion(parent);
+
+          expect(containerElementAssertion.toContainElement(parent)).toBe(containerElementAssertion);
+          expect(containerElementAssertion.toContainElement(child)).toBe(containerElementAssertion);
+          expect(containerElementAssertion.toContainElement(text)).toBe(containerElementAssertion);
+          expect(parentElementAssertion.toContainElement(child)).toBe(parentElementAssertion);
+        });
+
+        it("throws an error for negative assertion", () => {
+          const { getByText, getByTestId } = render(<ContainElementTestComponent />);
+
+          const container = getByTestId("grandParent");
+          const parent = getByTestId("parent");
+          const text = getByText("text");
+
+          const containerElementAssertion = new ElementAssertion(container);
+
+          expect(() => containerElementAssertion.not.toContainElement(parent))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> NOT to contain element <View ... />.");
+          expect(() => containerElementAssertion.not.toContainElement(text))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> NOT to contain element <Text ... />.");
+        });
+      });
+
+      context("and the target element is NOT found in the children's element", () => {
+        it("throws an error", () => {
+          const { getByText, getByTestId } = render(<ContainElementTestComponent />);
+
+          const parent = getByTestId("parent");
+          const text = getByText("text");
+
+          const parentElementAssertion = new ElementAssertion(parent);
+
+          expect(() => parentElementAssertion.toContainElement(text))
+            .toThrowError(AssertionError)
+            .toHaveMessage("Expected element <View ... /> to contain element <Text ... />.");
+        });
+
+        it("returns the assertion instance for negative assertion", () => {
+          const { getByText, getByTestId } = render(<ContainElementTestComponent />);
+
+          const container = getByTestId("grandParent");
+          const parent = getByTestId("parent");
+          const text = getByText("text");
+
+          const parentElementAssertion = new ElementAssertion(parent);
+
+          expect(parentElementAssertion.not.toContainElement(text)).toBeEqual(parentElementAssertion);
+          expect(parentElementAssertion.not.toContainElement(container)).toBeEqual(parentElementAssertion);
+        });
+      });
+    });
+
+    context("when the element does NOT have children", () => {
+
+      it("throws an error", () => {
+        const { getByText, getByTestId } = render(<ContainElementTestComponent />);
+
+        const parent = getByTestId("parent");
+        const text = getByText("text");
+
+        const textElementAssertion = new ElementAssertion(text);
+        expect(() => textElementAssertion.toContainElement(parent))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> to contain element <View ... />.");
+      });
+    });
+  });
+
+  describe(".toHaveProp", () => {
+    context("when the element contains the target prop", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <View testID="id" accessibilityLabel="label" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.toHaveProp("accessibilityLabel")).toBe(test);
+        expect(() => test.not.toHaveProp("accessibilityLabel"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to have prop 'accessibilityLabel'.");
+      });
+    });
+
+    context("when the element does NOT contain the target prop", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveProp("accessibilityLabel")).toBeEqual(test);
+        expect(() => test.toHaveProp("accessibilityLabel"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> to have prop 'accessibilityLabel'.");
+      });
+    });
+
+    context("when the element contains the target prop with a specific value", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <View testID="id" accessibilityLabel="label" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.toHaveProp("accessibilityLabel", "label")).toBe(test);
+        expect(() => test.not.toHaveProp("accessibilityLabel", "label"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to have prop 'accessibilityLabel' with value 'label'.");
+      });
+    });
+
+    context("when the element does NOT contain the target prop with a specific value", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id" accessibilityLabel="new-label" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveProp("accessibilityLabel", "label")).toBeEqual(test);
+        expect(() => test.toHaveProp("accessibilityLabel", "label"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> to have prop 'accessibilityLabel' with value 'label'.");
+      });
+    });
+  });
+
+  describe(".toHaveStyle", () => {
+    context("when the element contains the target style", () => {
+      it("returns the assertion instance", () => {
+      const element = render(
+        <View testID="id" style={{ backgroundColor: "red" }} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.toHaveStyle({ backgroundColor: "red" })).toBe(test);
+      expect(() => test.not.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> NOT to have style: \n\t- backgroundColor: red;");
+      });
+    });
+
+    context("when the element does NOT contain the target style", () => {
+      it("throws an error", () => {
+        const element = render(
+        <View testID="id" style={{ opacity: 1 }} />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveStyle({ backgroundColor: "red" })).toBeEqual(test);
+        expect(() => test.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;");
+      });
+    });
+
+    context("when the element contains multiple styles and matches all", () => {
+      it("returns the assertion instance", () => {
+      const element = render(
+        <View testID="id" style={{ backgroundColor: "red", opacity: 0.5 }} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.toHaveStyle({ backgroundColor: "red", opacity: 0.5 })).toBe(test);
+      expect(() => test.not.toHaveStyle({ backgroundColor: "red", opacity: 0.5 }))
+        .toThrowError(AssertionError)
+        .toHaveMessage(
+          "Expected element <View ... /> NOT to have style: \n\t- backgroundColor: red;\n\t- opacity: 0.5;",
+        );
+      });
+    });
+
+    context("when the element contains multiple styles but does not match all", () => {
+      it("throws an error", () => {
+      const element = render(
+        <View testID="id" style={{ backgroundColor: "red", opacity: 1 }} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.not.toHaveStyle({ backgroundColor: "red", opacity: 0.5 })).toBeEqual(test);
+      expect(() => test.toHaveStyle({ backgroundColor: "red", opacity: 0.5 }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;\n\t- opacity: 0.5;");
+      });
+    });
+
+    context("when the element has no style prop", () => {
+      it("throws an error", () => {
+      const element = render(
+        <View testID="id" />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.not.toHaveStyle({ backgroundColor: "red" })).toBeEqual(test);
+      expect(() => test.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;");
+      });
+    });
+
+    context("when the element style is an array and contains the target style", () => {
+      it("returns the assertion instance", () => {
+      const element = render(
+        <View testID="id" style={[{ backgroundColor: "red" }, { opacity: 0.5 }]} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.toHaveStyle({ backgroundColor: "red", opacity: 0.5 })).toBe(test);
+      expect(() => test.not.toHaveStyle({ backgroundColor: "red", opacity: 0.5 }))
+        .toThrowError(AssertionError)
+        .toHaveMessage(
+          "Expected element <View ... /> NOT to have style: \n\t- backgroundColor: red;\n\t- opacity: 0.5;",
+        );
+      });
+    });
+
+    context("when the passed style is an array and contains the target style", () => {
+      it("returns the assertion instance", () => {
+      const element = render(
+        <View testID="id" style={[{ backgroundColor: "red" }, { opacity: 0.5 }]} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+      expect(test.toHaveStyle([{ backgroundColor: "red" }, { opacity: 0.5 }])).toBe(test);
+      expect(() => test.not.toHaveStyle([{ backgroundColor: "red" }, { opacity: 0.5 }]))
+        .toThrowError(AssertionError)
+        .toHaveMessage(
+          "Expected element <View ... /> NOT to have style: \n\t- backgroundColor: red;\n\t- opacity: 0.5;",
+        );
+      });
+    });
+
+    context("when the element style is an array and does not contain the target style", () => {
+      it("throws an error", () => {
+      const element = render(
+        <View testID="id" style={[{ backgroundColor: "blue" }, { opacity: 1 }]} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.not.toHaveStyle({ backgroundColor: "red" })).toBeEqual(test);
+      expect(() => test.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;");
+      });
+    });
+
+    context("when the style value is undefined", () => {
+      it("throws an error", () => {
+      const element = render(
+        <View testID="id" style={{ backgroundColor: undefined }} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.not.toHaveStyle({ backgroundColor: "red" })).toBeEqual(test);
+      expect(() => test.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;");
+      });
+    });
+
+    context("when the style value is null", () => {
+      it("throws an error", () => {
+      const element = render(
+        <View testID="id" style={null} />,
+      );
+      const test = new ElementAssertion(element.getByTestId("id"));
+
+      expect(test.not.toHaveStyle({ backgroundColor: "red" })).toBeEqual(test);
+      expect(() => test.toHaveStyle({ backgroundColor: "red" }))
+        .toThrowError(AssertionError)
+        .toHaveMessage("Expected element <View ... /> to have style: \n\t- backgroundColor: red;");
+      });
+    });
+  });
+
+  describe(".toHaveTextContent", () => {
+    context("when the element contains the target text", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.toHaveTextContent("Hello World")).toBe(test);
+        expect(() => test.not.toHaveTextContent("Hello World"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> NOT to have text content matching 'Hello World'.");
+      });
+    });
+
+    context("when the element does NOT contain the target text", () => {
+      it("throws an error", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent("Goodbye World")).toBeEqual(test);
+        expect(() => test.toHaveTextContent("Goodbye World"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> to have text content matching 'Goodbye World'.");
+      });
+    });
+
+    context("when the element contains the target text with a RegExp", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.toHaveTextContent(/Hello/)).toBe(test);
+        expect(() => test.not.toHaveTextContent(/Hello/))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> NOT to have text content matching '/Hello/'.");
+      });
+    });
+
+    context("when the element does NOT contain the target text with a RegExp", () => {
+      it("throws an error", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent(/Goodbye/)).toBeEqual(test);
+        expect(() => test.toHaveTextContent(/Goodbye/))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <Text ... /> to have text content matching '/Goodbye/'.");
+      });
+    });
+
+    context("when the eleme contains the target text within a child element", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <View testID="id">
+            <View>
+              <Text>{"Test 1"}</Text>
+              <View>
+                <Text>{"Test 2"}</Text>
+                <Text>{"Hello World"}</Text>
+              </View>
+            </View>
+          </View>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+        expect(test.toHaveTextContent("Hello World")).toBe(test);
+        expect(() => test.not.toHaveTextContent("Hello World"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> NOT to have text content matching 'Hello World'.");
+      });
+    });
+
+    context("when the element does NOT contain the target text within a child element", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id">
+            <View>
+              <Text>{"Test 1"}</Text>
+              <View>
+                <Text>{"Test 2"}</Text>
+                <Text>{"Hello World"}</Text>
+              </View>
+            </View>
+          </View>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+        expect(test.not.toHaveTextContent("Goodbye World")).toBeEqual(test);
+        expect(() => test.toHaveTextContent("Goodbye World"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> to have text content matching 'Goodbye World'.");
+      });
+    });
+
+    context("when the element contains the target text with a function matcher", () => {
+      it("returns the assertion instance", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.toHaveTextContent(text => text.startsWith("Hello"))).toBe(test);
+        expect(() => test.not.toHaveTextContent(text => text.startsWith("Hello")))
+          .toThrowError(AssertionError)
+          .toHaveMessage(
+            "Expected element <Text ... /> NOT to have text content matching " +
+            "'text => text.startsWith(\"Hello\")'.",
+          );
+      });
+    });
+
+    context("when the element does NOT contain the target text with a function matcher", () => {
+      it("throws an error", () => {
+        const element = render(
+          <Text testID="id">{"Hello World"}</Text>,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent(text => text.startsWith("Goodbye"))).toBeEqual(test);
+        expect(() => test.toHaveTextContent(text => text.startsWith("Goodbye")))
+          .toThrowError(AssertionError)
+          .toHaveMessage(
+            "Expected element <Text ... /> to have text content matching " +
+            "'text => text.startsWith(\"Goodbye\")'.",
+          );
+      });
+    });
+
+    context("when the element has no text content", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent("Hello World")).toBeEqual(test);
+        expect(() => test.toHaveTextContent("Hello World"))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> to have text content matching 'Hello World'.");
+      });
+    });
+
+    context("when the element has no text content with a RegExp", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent(/Hello/)).toBeEqual(test);
+        expect(() => test.toHaveTextContent(/Hello/))
+          .toThrowError(AssertionError)
+          .toHaveMessage("Expected element <View ... /> to have text content matching '/Hello/'.");
+      });
+    });
+
+    context("when the element has no text content with a function matcher", () => {
+      it("throws an error", () => {
+        const element = render(
+          <View testID="id" />,
+        );
+        const test = new ElementAssertion(element.getByTestId("id"));
+
+        expect(test.not.toHaveTextContent(text => text.startsWith("Hello"))).toBeEqual(test);
+        expect(() => test.toHaveTextContent(text => text.startsWith("Hello")))
+          .toThrowError(AssertionError)
+          .toHaveMessage(
+            "Expected element <View ... /> to have text content matching " +
+            "'text => text.startsWith(\"Hello\")'.",
+          );
+      });
+    });
+  });
 });
diff --git a/packages/native/test/lib/fixtures/containElementTestComponent.tsx b/packages/native/test/lib/fixtures/containElementTestComponent.tsx
new file mode 100644
index 00000000..febbc269
--- /dev/null
+++ b/packages/native/test/lib/fixtures/containElementTestComponent.tsx
@@ -0,0 +1,18 @@
+import { ReactElement } from "react";
+import {
+  View,
+  Text,
+} from "react-native";
+
+export function ContainElementTestComponent(): ReactElement {
+return (
+    <View testID="grandParent">
+      <View testID="parent">
+        <View>
+          <Text>{"child"}</Text>
+        </View>
+      </View>
+      <Text>{"text"}</Text>
+    </View>
+    );
+}