diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 86b819b..dc43b17 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -16,6 +16,9 @@ or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any addi
 ## Table of Contents
 
 [Dev Environment](#dev-environment)
+[Rule Factory System](#rule-factory-system)
+[Creating New Rules](#creating-new-rules)
+[Utility Functions](#utility-functions)
 [Pull requests](#pull-requests)
 
 ## Dev Environment
@@ -61,6 +64,205 @@ To ensure a consistent and productive development environment, install the follo
 - [Prettier ESLint](https://marketplace.visualstudio.com/items?itemName=rvest.vs-code-prettier-eslint) — Format code with Prettier and ESLint integration.
 - [markdownlint](https://marketplace.visualstudio.com/items?itemName=DavidAnson.vscode-markdownlint) — Linting and style checks for Markdown files.
 
+## Rule Factory System
+
+This plugin uses a powerful rule factory system that provides consistent behavior across accessibility rules. The factory system is built around the `ruleFactory` function in `lib/util/ruleFactory.ts` and several utility functions for validating accessible labeling.
+
+### Core Concept
+
+The rule factory centralizes common accessibility validation patterns, making it easy to create new rules with consistent behavior. Instead of implementing validation logic from scratch, rules can leverage the factory's built-in utilities.
+
+### Architecture
+
+```sh
+ruleFactory(config) → ESLint Rule
+    ↓
+hasAccessibleLabel(opening, element, context, config) → boolean
+    ↓
+Utility Functions:
+├── hasAssociatedLabelViaAriaLabelledBy(opening, context)
+├── hasAssociatedLabelViaHtmlFor(opening, context)  
+├── hasAssociatedLabelViaAriaDescribedby(opening, context)
+├── hasLabeledChild(opening, context)
+├── hasTextContentChild(element)
+└── isInsideLabelTag(context)
+```
+
+## Creating New Rules
+
+### Using the Rule Factory
+
+For most accessibility rules, use the rule factory:
+
+```typescript
+import { ruleFactory, LabeledControlConfig } from '../util/ruleFactory';
+
+const rule = ruleFactory({
+  component: 'YourComponent', // string or regex pattern
+  message: 'YourComponent needs accessible labeling',
+  
+  // Validation options (all optional, default false)
+  allowTextContentChild: true,      // Allow text content in children
+  allowLabeledChild: true,          // Allow images with alt, icons, etc.
+  allowHtmlFor: true,               // Allow htmlFor/id label association
+  allowLabelledBy: true,            // Allow aria-labelledby
+  allowDescribedBy: false,          // Allow aria-describedby (discouraged as primary)
+  allowWrappingLabel: true,         // Allow wrapping in <Label> tag
+  allowTooltipParent: false,        // Allow parent <Tooltip>
+  allowFieldParent: true,           // Allow parent <Field>
+  
+  // Property validation
+  labelProps: ['aria-label'],       // Props that provide labeling
+  requiredProps: ['role'],          // Props that must be present
+});
+
+export default rule;
+```
+
+### Configuration Options
+
+| Option | Description | Example Use Cases |
+|--------|-------------|-------------------|
+| `allowTextContentChild` | Allows text content in child elements | Buttons, links with text |
+| `allowLabeledChild` | Allows accessible child content (images with alt, icons, aria-labeled elements) | Icon buttons, image buttons |
+| `allowHtmlFor` | Allows label association via `htmlFor`/`id` | Form inputs, interactive controls |
+| `allowLabelledBy` | Allows `aria-labelledby` references | Complex components referencing external labels |
+| `allowDescribedBy` | Allows `aria-describedby` (discouraged for primary labeling) | Rare cases where description suffices |
+| `allowWrappingLabel` | Allows element to be wrapped in `<Label>` | Form controls |
+| `allowTooltipParent` | Allows parent `<Tooltip>` as accessible name | Simple tooltips (use sparingly) |
+| `allowFieldParent` | Allows parent `<Field>` component | FluentUI form fields |
+
+### Custom Rules
+
+For complex validation that doesn't fit the factory pattern:
+
+```typescript
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import { JSXOpeningElement } from "estree-jsx";
+
+const rule = ESLintUtils.RuleCreator.withoutDocs({
+  defaultOptions: [],
+  meta: {
+    messages: {
+      customMessage: "Custom validation message"
+    },
+    type: "problem",
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node: TSESTree.JSXOpeningElement) {
+        // Custom validation logic
+        if (needsValidation(node)) {
+          context.report({
+            node,
+            messageId: "customMessage"
+          });
+        }
+      }
+    };
+  }
+});
+```
+
+## Utility Functions
+
+### hasLabeledChild
+
+The `hasLabeledChild` utility detects accessible child content and is one of the most powerful validation functions:
+
+```typescript
+import { hasLabeledChild } from '../util/hasLabeledChild';
+
+// Usage in rules
+if (hasLabeledChild(openingElement, context)) {
+  return; // Element has accessible child content
+}
+```
+
+**Detects:**
+
+1. **Images with alt text:**
+   ```jsx
+   <Button><img alt="Save document" /></Button>
+   <Button><Image alt="User profile" /></Button>
+   ```
+
+2. **SVG elements with accessible attributes:**
+   ```jsx
+   <Button><svg title="Close" /></Button>
+   <Button><svg aria-label="Menu" /></Button>
+   <Button><svg aria-labelledby="icon-label" /></Button>
+   ```
+
+3. **Elements with role="img" and labeling:**
+   ```jsx
+   <Button><span role="img" aria-label="Celebration">🎉</span></Button>
+   ```
+
+4. **FluentUI Icon components:**
+   ```jsx
+   <Button><SaveIcon /></Button>
+   <Button><Icon iconName="Save" /></Button>
+   <Button><MyCustomIcon /></Button>
+   ```
+
+5. **Any element with aria-label or title:**
+   ```jsx
+   <Button><div aria-label="Status indicator" /></Button>
+   <Button><span title="Tooltip text" /></Button>
+   ```
+
+6. **Elements with validated aria-labelledby:**
+   ```jsx
+   <Button><span aria-labelledby="save-label" /></Button>
+   <Label id="save-label">Save Document</Label>
+   ```
+
+**Key Features:**
+
+- **Source code validation:** Validates that `aria-labelledby` references point to actual elements with matching IDs
+- **Deep traversal:** Uses `flattenChildren` to find labeled content in nested structures
+- **Case insensitive:** Handles variations like `IMG`, `SVG`, `CLOSEICON`
+- **Error handling:** Gracefully handles malformed JSX and missing context
+
+### Other Utility Functions
+
+- **`hasAssociatedLabelViaAriaLabelledBy(opening, context)`** - Validates `aria-labelledby` references
+- **`hasAssociatedLabelViaHtmlFor(opening, context)`** - Validates `htmlFor`/`id` label associations  
+- **`hasAssociatedLabelViaAriaDescribedby(opening, context)`** - Validates `aria-describedby` references
+- **`hasTextContentChild(element)`** - Checks for meaningful text content in children
+- **`isInsideLabelTag(context)`** - Checks if element is wrapped in a `<Label>` tag
+- **`hasNonEmptyProp(attributes, propName)`** - Validates non-empty attribute values
+- **`hasDefinedProp(attributes, propName)`** - Checks if attribute is present
+
+### Writing Tests
+
+Use the comprehensive test patterns established in the codebase:
+
+```typescript
+import { hasLabeledChild } from "../../../../lib/util/hasLabeledChild";
+import { TSESLint } from "@typescript-eslint/utils";
+
+describe("hasLabeledChild", () => {
+  const mockContext = (sourceText = ""): TSESLint.RuleContext<string, unknown[]> => ({
+    getSourceCode: () => ({
+      getText: () => sourceText,
+      text: sourceText
+    })
+  } as unknown as TSESLint.RuleContext<string, unknown[]>);
+
+  it("validates aria-labelledby references", () => {
+    const element = createElementWithChild("div", [
+      createJSXAttribute("aria-labelledby", "existing-label")
+    ]);
+    const contextWithLabel = mockContext('<Label id="existing-label">Label Text</Label>');
+    
+    expect(hasLabeledChild(element, contextWithLabel)).toBe(true);
+  });
+});
+```
+
 ## To create a new ESLint rule
 
 If you want to create a new ESLint rule:
diff --git a/README.md b/README.md
index 420bf64..2eda206 100644
--- a/README.md
+++ b/README.md
@@ -90,6 +90,69 @@ This plugin does a static code analysis of the React JSX to spot accessibility i
 
 As the plugin can only catch errors in static source code, please use it in combination with [@axe-core/react](https://github.com/dequelabs/axe-core-npm/tree/develop/packages/react) to test the accessibility of the rendered DOM. Consider these tools just as one step of a larger a11y testing process and always test your apps with assistive technology.
 
+## Architecture & Development
+
+### Rule Factory System
+
+This plugin leverages a powerful rule factory system that provides consistent behavior across accessibility rules. The factory system includes several utility functions for validating accessible labeling:
+
+- **`hasAssociatedLabelViaAriaLabelledBy`** - Validates `aria-labelledby` references
+- **`hasAssociatedLabelViaHtmlFor`** - Validates `htmlFor`/`id` label associations  
+- **`hasAssociatedLabelViaAriaDescribedby`** - Validates `aria-describedby` references
+- **`hasLabeledChild`** - Detects accessible child content (images with alt, icons, labeled elements)
+- **`hasTextContentChild`** - Validates text content in child elements
+- **`isInsideLabelTag`** - Checks if element is wrapped in a label
+
+#### Labeled Child Detection
+
+The `hasLabeledChild` utility is particularly powerful, detecting multiple forms of accessible child content:
+
+```tsx
+// Image elements with alt text
+<Button><img alt="Save document" /></Button>
+
+// SVG elements with accessible attributes  
+<Button><svg title="Close" /></Button>
+<Button><svg aria-label="Menu" /></Button>
+
+// Elements with role="img" and labeling
+<Button><span role="img" aria-label="Celebration">🎉</span></Button>
+
+// FluentUI Icon components
+<Button><SaveIcon /></Button>
+<Button><Icon iconName="Save" /></Button>
+
+// Any element with aria-label or title
+<Button><div aria-label="Status indicator" /></Button>
+
+// Elements with aria-labelledby (validates references exist)
+<Button><span aria-labelledby="save-label" /></Button>
+<Label id="save-label">Save Document</Label>
+```
+
+The utility performs source code analysis to validate that `aria-labelledby` references point to actual elements with matching IDs, ensuring robust accessibility validation.
+
+### Creating New Rules
+
+To create a new accessibility rule, use the rule factory system:
+
+```typescript
+import { ruleFactory, LabeledControlConfig } from '../util/ruleFactory';
+
+const rule = ruleFactory({
+  component: 'YourComponent', // or /RegexPattern/
+  message: 'Your component needs accessible labeling',
+  allowTextContentChild: true,
+  allowLabeledChild: true,
+  allowHtmlFor: true,
+  allowLabelledBy: true,
+  labelProps: ['aria-label'],
+  requiredProps: ['role']
+});
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development guidelines.
+
 ## Trademarks
 
 This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
diff --git a/lib/util/hasLabeledChild.ts b/lib/util/hasLabeledChild.ts
index 3743cfd..ac42704 100644
--- a/lib/util/hasLabeledChild.ts
+++ b/lib/util/hasLabeledChild.ts
@@ -1,10 +1,88 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import { TSESTree } from "@typescript-eslint/utils";
+import { TSESLint } from "@typescript-eslint/utils";
+import { flattenChildren } from "./flattenChildren";
+import { hasNonEmptyProp } from "./hasNonEmptyProp";
+import { hasAssociatedAriaText } from "./labelUtils";
 
-// eslint-disable-next-line no-unused-vars
+/**
+ * Checks if a JSX element has properly labeled child elements that can serve as an accessible name.
+ * This includes child elements with alt text, aria-label, title attributes, or other accessibility attributes.
+ *
+ * Examples of labeled children:
+ * - <img alt="User profile" />
+ * - <svg title="Close icon" />
+ * - <Icon aria-label="Settings" />
+ * - <span role="img" aria-label="Emoji">🎉</span>
+ * - <div aria-labelledby="existingId">Content</div>
+ *
+ * @param openingElement - The JSX opening element to check
+ * @param context - ESLint rule context for accessing source code and validating references
+ * @returns true if the element has accessible labeled children
+ */
 export const hasLabeledChild = (openingElement: TSESTree.JSXOpeningElement, context: TSESLint.RuleContext<string, unknown[]>): boolean => {
-    // TODO: function not yet implemented
-    return false;
+    try {
+        let node: TSESTree.JSXElement | null = null;
+
+        if (openingElement.parent && openingElement.parent.type === "JSXElement") {
+            node = openingElement.parent as TSESTree.JSXElement;
+        }
+
+        if (!node?.children || node.children.length === 0) {
+            return false;
+        }
+
+        const allChildren = flattenChildren(node);
+
+        return allChildren.some(child => {
+            if (child.type === "JSXElement") {
+                const childOpeningElement = child.openingElement;
+                const childName = childOpeningElement.name;
+
+                if (childName.type === "JSXIdentifier") {
+                    const tagName = childName.name.toLowerCase();
+
+                    if ((tagName === "img" || tagName === "image") && hasNonEmptyProp(childOpeningElement.attributes, "alt")) {
+                        return true;
+                    }
+
+                    if (tagName === "svg") {
+                        return (
+                            hasNonEmptyProp(childOpeningElement.attributes, "title") ||
+                            hasNonEmptyProp(childOpeningElement.attributes, "aria-label") ||
+                            hasAssociatedAriaText(childOpeningElement, context, "aria-labelledby")
+                        );
+                    }
+
+                    if (hasNonEmptyProp(childOpeningElement.attributes, "role")) {
+                        const roleProp = childOpeningElement.attributes.find(
+                            attr => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "role"
+                        );
+
+                        if (roleProp?.type === "JSXAttribute" && roleProp.value?.type === "Literal" && roleProp.value.value === "img") {
+                            return (
+                                hasNonEmptyProp(childOpeningElement.attributes, "aria-label") ||
+                                hasAssociatedAriaText(childOpeningElement, context, "aria-labelledby")
+                            );
+                        }
+                    }
+
+                    if (
+                        tagName.toLowerCase().includes("icon") ||
+                        hasNonEmptyProp(childOpeningElement.attributes, "aria-label") ||
+                        hasNonEmptyProp(childOpeningElement.attributes, "title") ||
+                        hasAssociatedAriaText(childOpeningElement, context, "aria-labelledby")
+                    ) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        });
+    } catch (error) {
+        return false;
+    }
 };
diff --git a/tests/lib/rules/utils/hasLabeledChild.test.ts b/tests/lib/rules/utils/hasLabeledChild.test.ts
new file mode 100644
index 0000000..8ee88d5
--- /dev/null
+++ b/tests/lib/rules/utils/hasLabeledChild.test.ts
@@ -0,0 +1,475 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
+import { TSESLint } from "@typescript-eslint/utils";
+import { hasLabeledChild } from "../../../../lib/util/hasLabeledChild";
+
+const mockLocRange = () => ({
+    loc: {
+        start: { line: 0, column: 0 },
+        end: { line: 0, column: 0 }
+    },
+    range: [0, 0] as [number, number]
+});
+
+const mockContext = (sourceText = ""): TSESLint.RuleContext<string, unknown[]> => {
+    return {
+        getSourceCode: () => ({
+            getText: () => sourceText,
+            text: sourceText
+        })
+    } as unknown as TSESLint.RuleContext<string, unknown[]>;
+};
+
+const createJSXAttribute = (name: string, value?: string | number): TSESTree.JSXAttribute => ({
+    type: AST_NODE_TYPES.JSXAttribute,
+    name: {
+        type: AST_NODE_TYPES.JSXIdentifier,
+        name,
+        ...mockLocRange()
+    },
+    value:
+        value !== undefined
+            ? {
+                  type: AST_NODE_TYPES.Literal,
+                  value,
+                  raw: typeof value === "string" ? `"${value}"` : String(value),
+                  ...mockLocRange()
+              }
+            : null,
+    ...mockLocRange()
+});
+
+const createJSXOpeningElement = (tagName: string, attributes: TSESTree.JSXAttribute[] = []): TSESTree.JSXOpeningElement => ({
+    type: AST_NODE_TYPES.JSXOpeningElement,
+    name: {
+        type: AST_NODE_TYPES.JSXIdentifier,
+        name: tagName,
+        ...mockLocRange()
+    },
+    attributes,
+    selfClosing: false,
+    ...mockLocRange()
+});
+
+const createJSXElement = (
+    tagName: string,
+    attributes: TSESTree.JSXAttribute[] = [],
+    children: (TSESTree.JSXElement | TSESTree.JSXText | TSESTree.JSXExpressionContainer)[] = []
+): TSESTree.JSXElement => ({
+    type: AST_NODE_TYPES.JSXElement,
+    openingElement: createJSXOpeningElement(tagName, attributes),
+    closingElement: {
+        type: AST_NODE_TYPES.JSXClosingElement,
+        name: {
+            type: AST_NODE_TYPES.JSXIdentifier,
+            name: tagName,
+            ...mockLocRange()
+        },
+        ...mockLocRange()
+    },
+    children,
+    ...mockLocRange()
+});
+
+const createOpeningElementWithParent = (tagName: string, children: TSESTree.JSXElement[] = []): TSESTree.JSXOpeningElement => {
+    const parentElement = createJSXElement("Container", [], children);
+    const openingElement = createJSXOpeningElement(tagName);
+    openingElement.parent = parentElement;
+    return openingElement;
+};
+
+describe("hasLabeledChild", () => {
+    const defaultContext = mockContext();
+
+    describe("Basic functionality", () => {
+        it("returns false when node has no parent", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false when parent has no children", () => {
+            const openingElement = createOpeningElementWithParent("Button", []);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false when parent children is null", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const parentElement = createJSXElement("Container");
+            parentElement.children = null as any;
+            openingElement.parent = parentElement;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false when parent children is undefined", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const parentElement = createJSXElement("Container");
+            parentElement.children = undefined as any;
+            openingElement.parent = parentElement;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+    });
+
+    describe("Image elements with alt text", () => {
+        it("returns true for img with alt attribute", () => {
+            const imgChild = createJSXElement("img", [createJSXAttribute("alt", "User profile")]);
+            const openingElement = createOpeningElementWithParent("Button", [imgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for Image component with alt attribute", () => {
+            const imageChild = createJSXElement("Image", [createJSXAttribute("alt", "Product photo")]);
+            const openingElement = createOpeningElementWithParent("Card", [imageChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns false for img without alt attribute", () => {
+            const imgChild = createJSXElement("img", [createJSXAttribute("src", "photo.jpg")]);
+            const openingElement = createOpeningElementWithParent("Button", [imgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for img with empty alt attribute", () => {
+            const imgChild = createJSXElement("img", [createJSXAttribute("alt", "")]);
+            const openingElement = createOpeningElementWithParent("Button", [imgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+    });
+
+    describe("SVG elements", () => {
+        it("returns true for svg with title attribute", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("title", "Close icon")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for svg with aria-label", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("aria-label", "Menu icon")]);
+            const openingElement = createOpeningElementWithParent("MenuButton", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for svg with aria-labelledby that references existing element", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("aria-labelledby", "icon-label")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            const contextWithLabel = mockContext('<Label id="icon-label">Close Icon</Label>');
+            expect(hasLabeledChild(openingElement, contextWithLabel)).toBe(true);
+        });
+
+        it("returns false for svg with aria-labelledby that references non-existing element", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("aria-labelledby", "non-existing")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for svg without accessible attributes", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("viewBox", "0 0 24 24")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for svg with empty title", () => {
+            const svgChild = createJSXElement("svg", [createJSXAttribute("title", "")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+    });
+
+    describe("Elements with role='img'", () => {
+        it("returns true for element with role='img' and aria-label", () => {
+            const spanChild = createJSXElement("span", [
+                createJSXAttribute("role", "img"),
+                createJSXAttribute("aria-label", "Celebration emoji")
+            ]);
+            const openingElement = createOpeningElementWithParent("Button", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for element with role='img' and aria-labelledby that references existing element", () => {
+            const divChild = createJSXElement("div", [
+                createJSXAttribute("role", "img"),
+                createJSXAttribute("aria-labelledby", "emoji-label")
+            ]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithLabel = mockContext('<div id="emoji-label">Emoji Description</div>');
+            expect(hasLabeledChild(openingElement, contextWithLabel)).toBe(true);
+        });
+
+        it("returns false for element with role='img' and aria-labelledby that references non-existing element", () => {
+            const divChild = createJSXElement("div", [
+                createJSXAttribute("role", "img"),
+                createJSXAttribute("aria-labelledby", "non-existing")
+            ]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for element with role='img' but no aria-label", () => {
+            const spanChild = createJSXElement("span", [createJSXAttribute("role", "img")]);
+            const openingElement = createOpeningElementWithParent("Button", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns true for element with different role but aria-label", () => {
+            // Any element with aria-label should return true, regardless of role
+            const spanChild = createJSXElement("span", [
+                createJSXAttribute("role", "button"),
+                createJSXAttribute("aria-label", "Click me")
+            ]);
+            const openingElement = createOpeningElementWithParent("Container", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns false for element with different role and no accessible labeling", () => {
+            const spanChild = createJSXElement("span", [
+                createJSXAttribute("role", "button"),
+                createJSXAttribute("className", "my-button")
+            ]);
+            const openingElement = createOpeningElementWithParent("Container", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns true for element with different role but aria-labelledby reference", () => {
+            const spanChild = createJSXElement("span", [
+                createJSXAttribute("role", "button"),
+                createJSXAttribute("aria-labelledby", "existingLabel")
+            ]);
+            const openingElement = createOpeningElementWithParent("Container", [spanChild]);
+            const contextWithLabel = mockContext('<Label id="existingLabel">Button Label</Label>');
+            expect(hasLabeledChild(openingElement, contextWithLabel)).toBe(true);
+        });
+    });
+
+    describe("FluentUI Icon components", () => {
+        it("returns true for elements with 'icon' in name", () => {
+            const iconChild = createJSXElement("CloseIcon");
+            const openingElement = createOpeningElementWithParent("Button", [iconChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for Icon component", () => {
+            const iconChild = createJSXElement("Icon");
+            const openingElement = createOpeningElementWithParent("MenuButton", [iconChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for custom icon components", () => {
+            const iconChild = createJSXElement("MyCustomIcon");
+            const openingElement = createOpeningElementWithParent("Button", [iconChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+    });
+
+    describe("Elements with aria-label or title", () => {
+        it("returns true for any element with aria-label", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-label", "Status indicator")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for any element with title", () => {
+            const spanChild = createJSXElement("span", [createJSXAttribute("title", "Tooltip text")]);
+            const openingElement = createOpeningElementWithParent("Button", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true for any element with aria-labelledby that references existing element", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "status-label")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithLabel = mockContext('<Label id="status-label">Current Status</Label>');
+            expect(hasLabeledChild(openingElement, contextWithLabel)).toBe(true);
+        });
+
+        it("returns false for element with aria-labelledby that references non-existing element", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "non-existing")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for element with empty aria-label", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-label", "")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("returns false for element with empty title", () => {
+            const spanChild = createJSXElement("span", [createJSXAttribute("title", "")]);
+            const openingElement = createOpeningElementWithParent("Button", [spanChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+    });
+
+    describe("Complex nested structures", () => {
+        it("returns true when labeled child is nested deeply", () => {
+            const nestedImg = createJSXElement("img", [createJSXAttribute("alt", "Deep nested image")]);
+            const nestedDiv = createJSXElement("div", [], [nestedImg]);
+            const containerDiv = createJSXElement("div", [], [nestedDiv]);
+            const openingElement = createOpeningElementWithParent("Card", [containerDiv]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns true when any of multiple children has labels", () => {
+            const unlabeledDiv = createJSXElement("div");
+            const labeledIcon = createJSXElement("SaveIcon");
+            const unlabeledSpan = createJSXElement("span");
+            const openingElement = createOpeningElementWithParent("Button", [unlabeledDiv, labeledIcon, unlabeledSpan]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("returns false when multiple children exist but none are labeled", () => {
+            const unlabeledDiv = createJSXElement("div");
+            const unlabeledSpan = createJSXElement("span", [createJSXAttribute("className", "text")]);
+            const unlabeledImg = createJSXElement("img", [createJSXAttribute("src", "photo.jpg")]);
+            const openingElement = createOpeningElementWithParent("Button", [unlabeledDiv, unlabeledSpan, unlabeledImg]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+    });
+
+    describe("Edge cases and error handling", () => {
+        it("handles malformed JSX gracefully", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const malformedParent = {
+                type: AST_NODE_TYPES.JSXElement,
+                openingElement: createJSXOpeningElement("Container"),
+                closingElement: {
+                    type: AST_NODE_TYPES.JSXClosingElement,
+                    name: {
+                        type: AST_NODE_TYPES.JSXIdentifier,
+                        name: "Container",
+                        ...mockLocRange()
+                    },
+                    ...mockLocRange()
+                },
+                children: "not an array" as any,
+                ...mockLocRange()
+            } as TSESTree.JSXElement;
+            openingElement.parent = malformedParent;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("handles non-JSXElement children gracefully", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const parentElement = createJSXElement("Container");
+            parentElement.children = [
+                { type: AST_NODE_TYPES.JSXText, value: "text" } as any,
+                { type: AST_NODE_TYPES.JSXExpressionContainer } as any
+            ];
+            openingElement.parent = parentElement;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("handles elements with non-JSXIdentifier names", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const parentElement = createJSXElement("Container");
+            const childWithComplexName = {
+                type: AST_NODE_TYPES.JSXElement,
+                openingElement: {
+                    type: AST_NODE_TYPES.JSXOpeningElement,
+                    name: {
+                        type: AST_NODE_TYPES.JSXMemberExpression,
+                        object: { type: AST_NODE_TYPES.JSXIdentifier, name: "React" },
+                        property: { type: AST_NODE_TYPES.JSXIdentifier, name: "Fragment" }
+                    } as any,
+                    attributes: [],
+                    ...mockLocRange()
+                },
+                closingElement: {
+                    type: AST_NODE_TYPES.JSXClosingElement,
+                    name: {
+                        type: AST_NODE_TYPES.JSXMemberExpression,
+                        object: { type: AST_NODE_TYPES.JSXIdentifier, name: "React" },
+                        property: { type: AST_NODE_TYPES.JSXIdentifier, name: "Fragment" }
+                    } as any,
+                    ...mockLocRange()
+                },
+                children: [],
+                ...mockLocRange()
+            } as unknown as TSESTree.JSXElement;
+            parentElement.children = [childWithComplexName];
+            openingElement.parent = parentElement;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("handles attribute parsing errors gracefully", () => {
+            const openingElement = createJSXOpeningElement("Button");
+            const parentElement = createJSXElement("Container");
+            const childWithMalformedAttrs = createJSXElement("img");
+            childWithMalformedAttrs.openingElement.attributes = "not an array" as any;
+            parentElement.children = [childWithMalformedAttrs];
+            openingElement.parent = parentElement;
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(false);
+        });
+
+        it("handles context parsing errors gracefully", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "some-id")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const malformedContext = {
+                getSourceCode: () => {
+                    throw new Error("Source code not available");
+                }
+            } as unknown as TSESLint.RuleContext<string, unknown[]>;
+            expect(hasLabeledChild(openingElement, malformedContext)).toBe(false);
+        });
+    });
+
+    describe("Case sensitivity", () => {
+        it("handles uppercase IMG elements", () => {
+            const imgChild = createJSXElement("IMG", [createJSXAttribute("alt", "Uppercase image")]);
+            const openingElement = createOpeningElementWithParent("Button", [imgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("handles mixed case SVG elements", () => {
+            const svgChild = createJSXElement("SVG", [createJSXAttribute("title", "Mixed case SVG")]);
+            const openingElement = createOpeningElementWithParent("Button", [svgChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+
+        it("handles uppercase ICON in component names", () => {
+            const iconChild = createJSXElement("CLOSEICON");
+            const openingElement = createOpeningElementWithParent("Button", [iconChild]);
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+    });
+
+    describe("Integration with rule factory", () => {
+        it("integrates correctly with makeLabeledControlRule", () => {
+            const imgChild = createJSXElement("img", [createJSXAttribute("alt", "Integration test")]);
+            const openingElement = createOpeningElementWithParent("Button", [imgChild]);
+
+            expect(hasLabeledChild(openingElement, defaultContext)).toBe(true);
+        });
+    });
+
+    describe("aria-labelledby validation with context", () => {
+        it("validates multiple id references in aria-labelledby", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "label1 label2")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithMultipleLabels = mockContext('<Label id="label1">First</Label><div id="label2">Second</div>');
+            expect(hasLabeledChild(openingElement, contextWithMultipleLabels)).toBe(true);
+        });
+
+        it("returns true when at least one id reference exists (accessibility best practice)", () => {
+            // This is correct behavior: if at least one reference exists, the element has accessible labeling
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "exists missing")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithPartialLabels = mockContext('<Label id="exists">Exists</Label>');
+            expect(hasLabeledChild(openingElement, contextWithPartialLabels)).toBe(true);
+        });
+
+        it("returns false when no id references exist", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "missing1 missing2")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithNoLabels = mockContext('<Label id="other">Other Label</Label>');
+            expect(hasLabeledChild(openingElement, contextWithNoLabels)).toBe(false);
+        });
+
+        it("handles expression-based aria-labelledby references", () => {
+            const divChild = createJSXElement("div", [createJSXAttribute("aria-labelledby", "dynamic-id")]);
+            const openingElement = createOpeningElementWithParent("Card", [divChild]);
+            const contextWithExpressionLabel = mockContext('<Label id={"dynamic-id"}>Dynamic Label</Label>');
+            expect(hasLabeledChild(openingElement, contextWithExpressionLabel)).toBe(true);
+        });
+    });
+});
diff --git a/tests/lib/rules/utils/hasLabelledChilImage.test.ts b/tests/lib/rules/utils/hasLabelledChilImage.test.ts
index 07a9f45..f835d36 100644
--- a/tests/lib/rules/utils/hasLabelledChilImage.test.ts
+++ b/tests/lib/rules/utils/hasLabelledChilImage.test.ts
@@ -156,3 +156,147 @@ describe("hasLabelledChildImage", () => {
         expect(hasLabelledChildImage(node)).toBe(false);
     });
 });
+
+describe("hasLabelledChildImage - missing coverage", () => {
+    it("handles non-JSXElement children", () => {
+        const mockTextChild: TSESTree.JSXText = {
+            type: AST_NODE_TYPES.JSXText,
+            value: "Some text content",
+            raw: "Some text content",
+            ...createMockLocRange()
+        };
+
+        const mockExpressionChild: TSESTree.JSXExpressionContainer = {
+            type: AST_NODE_TYPES.JSXExpressionContainer,
+            expression: {
+                type: AST_NODE_TYPES.Literal,
+                value: "expression",
+                raw: '"expression"',
+                ...createMockLocRange()
+            },
+            ...createMockLocRange()
+        };
+
+        const node: TSESTree.JSXElement = {
+            type: AST_NODE_TYPES.JSXElement,
+            openingElement: {
+                type: AST_NODE_TYPES.JSXOpeningElement,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "Container", ...createMockLocRange() },
+                attributes: [],
+                selfClosing: false,
+                ...createMockLocRange()
+            },
+            closingElement: null,
+            children: [mockTextChild, mockExpressionChild],
+            ...createMockLocRange()
+        };
+
+        expect(hasLabelledChildImage(node)).toBe(false);
+    });
+
+    it("JSXElement child with non-image component name", () => {
+        const mockDivChild: TSESTree.JSXElement = {
+            type: AST_NODE_TYPES.JSXElement,
+            openingElement: {
+                type: AST_NODE_TYPES.JSXOpeningElement,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "div", ...createMockLocRange() }, // Not an image component
+                attributes: [
+                    {
+                        type: AST_NODE_TYPES.JSXAttribute,
+                        name: { type: AST_NODE_TYPES.JSXIdentifier, name: "alt", ...createMockLocRange() },
+                        value: { type: AST_NODE_TYPES.Literal, value: "description", raw: '"description"', ...createMockLocRange() },
+                        ...createMockLocRange()
+                    }
+                ],
+                selfClosing: false,
+                ...createMockLocRange()
+            },
+            closingElement: null,
+            children: [],
+            ...createMockLocRange()
+        };
+
+        const node: TSESTree.JSXElement = {
+            type: AST_NODE_TYPES.JSXElement,
+            openingElement: {
+                type: AST_NODE_TYPES.JSXOpeningElement,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "Container", ...createMockLocRange() },
+                attributes: [],
+                selfClosing: false,
+                ...createMockLocRange()
+            },
+            closingElement: null,
+            children: [mockDivChild],
+            ...createMockLocRange()
+        };
+
+        expect(hasLabelledChildImage(node)).toBe(false);
+    });
+});
+
+describe("isImageHidden - missing coverage for aria-label handling", () => {
+    it("returns false when aria-label has non-empty value", () => {
+        const attributes: TSESTree.JSXOpeningElement["attributes"] = [
+            {
+                type: AST_NODE_TYPES.JSXAttribute,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "aria-label", ...createMockLocRange() },
+                value: {
+                    type: AST_NODE_TYPES.Literal,
+                    value: "Descriptive label",
+                    raw: '"Descriptive label"',
+                    ...createMockLocRange()
+                },
+                ...createMockLocRange()
+            }
+        ];
+
+        expect(isImageHidden(attributes)).toBe(false);
+    });
+
+    it("returns false when aria-labelledby has non-empty value", () => {
+        const attributes: TSESTree.JSXOpeningElement["attributes"] = [
+            {
+                type: AST_NODE_TYPES.JSXAttribute,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "aria-labelledby", ...createMockLocRange() },
+                value: {
+                    type: AST_NODE_TYPES.Literal,
+                    value: "label-id",
+                    raw: '"label-id"',
+                    ...createMockLocRange()
+                },
+                ...createMockLocRange()
+            }
+        ];
+
+        expect(isImageHidden(attributes)).toBe(false);
+    });
+
+    it("handles case with both aria-label and aria-labelledby present", () => {
+        const attributes: TSESTree.JSXOpeningElement["attributes"] = [
+            {
+                type: AST_NODE_TYPES.JSXAttribute,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "aria-label", ...createMockLocRange() },
+                value: {
+                    type: AST_NODE_TYPES.Literal,
+                    value: "Primary label",
+                    raw: '"Primary label"',
+                    ...createMockLocRange()
+                },
+                ...createMockLocRange()
+            },
+            {
+                type: AST_NODE_TYPES.JSXAttribute,
+                name: { type: AST_NODE_TYPES.JSXIdentifier, name: "aria-labelledby", ...createMockLocRange() },
+                value: {
+                    type: AST_NODE_TYPES.Literal,
+                    value: "secondary-label",
+                    raw: '"secondary-label"',
+                    ...createMockLocRange()
+                },
+                ...createMockLocRange()
+            }
+        ];
+
+        expect(isImageHidden(attributes)).toBe(false);
+    });
+});