diff --git a/accessibility-checker-engine/help/group_withInputs_hasName.mdx b/accessibility-checker-engine/help/group_withInputs_hasName.mdx
new file mode 100644
index 000000000..bb7412cc9
--- /dev/null
+++ b/accessibility-checker-engine/help/group_withInputs_hasName.mdx
@@ -0,0 +1,80 @@
+---
+title: "group_withInputs_hasName - Accessibility Checker Rule Help"
+---
+import "../../../styles/ToolHelp.scss"
+import { CodeSnippet, Tag } from "carbon-components-react";
+
+<div className="toolHelp">
+<Row>
+<Column colLg={16} colMd={8} colSm={4} className="toolHead">
+
+### A `role="group"` or `<fieldset>` element does not have an accessible name or has a duplicate name
+
+<!-- This active message title is NOT used by the Checker, the browser extension uses the active messages: Fail_ or Potential_ message in ...nls/index.ts file instead -->
+
+
+<div id="locLevel"></div>
+
+<!-- the Checker browser extension displays the rule level, such as Violation, Needs Review, or Recommendation here -->
+
+  
+Multiple `<fieldset>` or `role="group"` elements with similar nested `<input>` elements must have unique labels 
+
+<!-- Checker does not display this passive message sub-title, the browser extension displays the 0: message in  ...nls/index.ts file -->
+
+<!-- Note that the messages in the test files must also match the messages from the ...nls/index.ts file instead of message titles here in mdx -->
+  
+
+</Column>
+</Row>
+
+<Row>
+<Column colLg={11} colMd={5} colSm={4} className="toolMain">
+
+  
+### Why is this important?
+
+A label associated with a group of related input elements also serves as a common label for individual inputs in the group. 
+Assistive technologies (AT) can indicate the start and end of the group and the group’s label as the user navigates into and out of the group.
+AT needs to be able to present the group label with each input control to remind users with which group they are part.
+When there are multiple groups with the same input elements then the label of the group needs to be unique so it can be distinguished.
+
+For example, in a retail scenario where two groups of input elements represent _Name, Address, City, and Zip_, 
+the groups need to be distinguished from one another by labelling one group "_Mailing address_" and the other "_Shipping address_".   
+
+<div id="locSnippet"></div>
+
+
+### What to do
+
+* Provide a unique label for a group of form controls using `<fieldset>` and `<legend>` elements  
+* **Or**, distinguish multiple `role="group"` elements with a unique `aria-labelledby` or `aria-label`  
+* **Or**, for a group of radio buttons, use `role="radiogroup"` instead of `role="group"`  
+
+</Column>
+<Column colLg={5} colMd={3} colSm={4} className="toolLeft">
+
+### About this requirement
+
+<!-- should only include one requirement and one or more references to techniques and best practices -->
+  
+* [IBM 1.3.1 Info and relationships](https://www.ibm.com/able/requirements/requirements/#1_3_1)
+* [IBM 3.3.2 Labels or Instructions](https://www.ibm.com/able/requirements/requirements/#3_3_2)
+* [WCAG technique ARIA 17](https://www.w3.org/WAI/WCAG21/Techniques/aria/ARIA17.html) 
+* [WCAG technique H71](https://www.w3.org/TR/WCAG20-TECHS/H71.html)
+* [WCAG technique F82](https://www.w3.org/TR/2016/NOTE-WCAG20-TECHS-20161007/F82)
+* [ARIA specification - Group Role]( https://www.w3.org/TR/wai-aria-1.2/#group)
+* [Carbon design system - Form accessibility](https://www.carbondesignsystem.com/components/form/accessibility/)  
+
+
+### Who does this affect?
+
+* People using a screen reader, including blind, low vision and neurodivergent people  
+* People with low vision using screen magnification  
+* People using other assistive technologies that expose accessibility information  
+
+</Column>
+</Row>
+</div>
+
+export default ({ children, _frontmatter }) => (<React.Fragment>{children}</React.Fragment>)
diff --git a/accessibility-checker-engine/src/v2/aria/ARIAMapper.ts b/accessibility-checker-engine/src/v2/aria/ARIAMapper.ts
index e756c2c80..11b2f6b65 100644
--- a/accessibility-checker-engine/src/v2/aria/ARIAMapper.ts
+++ b/accessibility-checker-engine/src/v2/aria/ARIAMapper.ts
@@ -409,9 +409,23 @@ export class ARIAMapper extends CommonMapper {
             if (cur.nodeName.toLowerCase() === "input" && elem.hasAttribute("id") && elem.getAttribute("id").length > 0) {
                 let label = elem.ownerDocument.querySelector("label[for='"+elem.getAttribute("id")+"']");
                 if (label) {
-                    return this.computeNameHelp(walkId, label, false, false);
+                    if (label.hasAttribute("aria-label") || label.hasAttribute("aria-labelledby")) {
+                        return this.computeNameHelp(walkId, label, false, false);
+                    } else {
+                        return label.textContent;
+                    }
+                }
+            }
+            if (cur.nodeName.toLowerCase() === "fieldset") {
+                if( (<Element>cur).querySelector("legend")){
+                    let legend = (<Element>cur).querySelector("legend");
+                    return legend.innerText;
+                }else{
+                    return this.computeNameHelp(walkId, cur, false, false);
                 }
+                            
             }
+            
         }
 
         // 2e.
diff --git a/accessibility-checker-engine/src/v2/checker/accessibility/help/index.ts b/accessibility-checker-engine/src/v2/checker/accessibility/help/index.ts
index 827437a1a..820105492 100644
--- a/accessibility-checker-engine/src/v2/checker/accessibility/help/index.ts
+++ b/accessibility-checker-engine/src/v2/checker/accessibility/help/index.ts
@@ -862,6 +862,13 @@ let a11yHelp = {
         "Pass_0": `${Config.helpRoot}/Rpt_Aria_ArticleRoleLabel_Implicit`,
         "Fail_1": `${Config.helpRoot}/Rpt_Aria_ArticleRoleLabel_Implicit`
     },
+    // ALI - DONE
+    "group_withInputs_hasName": {
+        0: `${Config.helpRoot}/group_withInputs_hasName`,
+        "Pass_1": `${Config.helpRoot}/group_withInputs_hasName`,
+        "Fail_1": `${Config.helpRoot}/group_withInputs_hasName`,
+        "Fail_2": `${Config.helpRoot}/group_withInputs_hasName`
+    },
     // JCH - DONE
     // "Rpt_Aria_MultipleGroupRoles_Implicit": {
     //     0: `${Config.helpRoot}/Rpt_Aria_MultipleGroupRoles_Implicit`,
diff --git a/accessibility-checker-engine/src/v2/checker/accessibility/nls/index.ts b/accessibility-checker-engine/src/v2/checker/accessibility/nls/index.ts
index 7a0fbac23..d7a0cbd52 100644
--- a/accessibility-checker-engine/src/v2/checker/accessibility/nls/index.ts
+++ b/accessibility-checker-engine/src/v2/checker/accessibility/nls/index.ts
@@ -855,6 +855,14 @@ let a11yNls = {
         "Pass_0": "Rule Passed",
         "Fail_1": "The element with \"article\" role does not have a label"
     },
+    
+    // ALI - DONE
+    "group_withInputs_hasName": {
+        0: "Groups with nested inputs must have unique accessible name", 
+        "Pass_1": "Group/Fieldset \"{0}\" with an input has a unique name",
+        "Fail_1": "Group/Fieldset does not have an accessible name",
+        "Fail_2": "Group/Fieldset \"{0}\" has a duplicate name to another group"
+    },
     // JCH - DONE
     // "Rpt_Aria_MultipleGroupRoles_Implicit": {
     //     0: "Each element with \"group\" role must have a unique label that describes its purpose",
diff --git a/accessibility-checker-engine/src/v2/checker/accessibility/rules/rpt-ariaLabeling-rules.ts b/accessibility-checker-engine/src/v2/checker/accessibility/rules/rpt-ariaLabeling-rules.ts
index 8aebcaf74..9cc998a2e 100644
--- a/accessibility-checker-engine/src/v2/checker/accessibility/rules/rpt-ariaLabeling-rules.ts
+++ b/accessibility-checker-engine/src/v2/checker/accessibility/rules/rpt-ariaLabeling-rules.ts
@@ -14,7 +14,15 @@
     limitations under the License.
  *****************************************************************************/
 
-import { Rule, RuleResult, RuleFail, RuleContext, RulePotential, RuleManual, RulePass } from "../../../api/IEngine";
+import {
+    Rule,
+    RuleResult,
+    RuleFail,
+    RuleContext,
+    RulePotential,
+    RuleManual,
+    RulePass,
+} from "../../../api/IEngine";
 import { RPTUtil } from "../util/legacy";
 import { ARIADefinitions } from "../../../aria/ARIADefinitions";
 import { FragmentUtil } from "../util/fragment";
@@ -25,24 +33,32 @@ import { DOMWalker } from "../../../dom/DOMWalker";
 let a11yRulesLabeling: Rule[] = [
     {
         /**
-         * Description: Triggers if a landmark element has the same parent-landmark, 
-         * AND the same role as another landmark, 
-         * AND is not differentiated by aria-label or aria-labelledby. 
+         * Description: Triggers if a landmark element has the same parent-landmark,
+         * AND the same role as another landmark,
+         * AND is not differentiated by aria-label or aria-labelledby.
          * This causes it to be difficult for a keyboard user to know the difference between two landmarks
          * Origin:  https://www.w3.org/WAI/WCAG21/Techniques/aria/ARIA13 this is not directly part of the ARIA spec so this is only in the IBM rules as a Violation
-         * 
-         * NOTE: When we have two landmarks at the root level of the document this rule will not check for that. 
-         * For example if we have <body> <main id="main1"></main> <main id="main2"><main> </body> we do not fail this rule. 
+         *
+         * NOTE: When we have two landmarks at the root level of the document this rule will not check for that.
+         * For example if we have <body> <main id="main1"></main> <main id="main2"><main> </body> we do not fail this rule.
          * Althought this might be an accessibility error anyway. See:
          * https://stackoverflow.com/questions/34896476/can-i-use-more-than-one-main-html-tag-in-the-same-page/34906037
          */
         id: "landmark_name_unique",
-        context: "aria:complementary, aria:banner, aria:contentinfo, aria:main, aria:navigation, aria:region, aria:search, aria:form",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        context:
+            "aria:complementary, aria:banner, aria:contentinfo, aria:main, aria:navigation, aria:region, aria:search, aria:form",
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             // TODO do I need to fiter out bad contentinfo nodes: The footer element is not a contentinfo landmark when it is a descendant of the following HTML5 sectioning elements: https://www.w3.org/TR/2017/NOTE-wai-aria-practices-1.1-20171214/examples/landmarks/HTML5.html
             const ruleContext = context["dom"].node as Element;
             let ownerDocument = FragmentUtil.getOwnerFragment(ruleContext);
-            let formCache = RPTUtil.getCache(ruleContext.ownerDocument, "landmark_name_unique", null);
+            let formCache = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "landmark_name_unique",
+                null
+            );
 
             if (!formCache) {
                 // console.log("---------ENTERING FORM CACHE")
@@ -50,94 +66,143 @@ let a11yRulesLabeling: Rule[] = [
                     navigationNodes: [],
                     navigationNodesComputedLabels: [],
                     navigationNodesParents: [],
-                    navigationNodesMatchFound: []
-                }
-                let navigationNodesTemp = ownerDocument.querySelectorAll('aside,[role="complementary"], footer,[role="contentinfo"], header,[role="banner"], main,[role="main"], nav,[role="navigation"], form,[role="form"], section,[role="region"],[role="search"]');
+                    navigationNodesMatchFound: [],
+                };
+                let navigationNodesTemp = ownerDocument.querySelectorAll(
+                    'aside,[role="complementary"], footer,[role="contentinfo"], header,[role="banner"], main,[role="main"], nav,[role="navigation"], form,[role="form"], section,[role="region"],[role="search"]'
+                );
                 let navigationNodes = Array.from(navigationNodesTemp);
                 let navigationNodesParents = [];
                 let navigationNodesMatchFound = [];
 
-                for (let i = 0; i < navigationNodes.length; i++) { // Loop over all the landmark nodes
+                for (let i = 0; i < navigationNodes.length; i++) {
+                    // Loop over all the landmark nodes
                     let els = [];
-                    let a = navigationNodes[i].parentElement
+                    let a = navigationNodes[i].parentElement;
                     while (a) {
                         els.push(a);
                         a = a.parentElement;
                     }
 
-                    for (let j = 0; j < els.length; j++) { // Loop over all the parents of the landmark nodes
-                        // Find nearest landmark parent based on the tagName or the role attribute 
-                        let tagNameTrigger = ["ASIDE", "FOOTER", "FORM", "HEADER", "MAIN", "NAV", "SECTION"].includes(els[j].tagName)
+                    for (let j = 0; j < els.length; j++) {
+                        // Loop over all the parents of the landmark nodes
+                        // Find nearest landmark parent based on the tagName or the role attribute
+                        let tagNameTrigger = [
+                            "ASIDE",
+                            "FOOTER",
+                            "FORM",
+                            "HEADER",
+                            "MAIN",
+                            "NAV",
+                            "SECTION",
+                        ].includes(els[j].tagName);
                         let roleNameTrigger = false;
                         if (els[j].hasAttribute("role")) {
-                            roleNameTrigger = ["complementary", "contentinfo", "form", "banner", "main", "navigation", "region", "search"].includes(els[j].getAttribute("role")) // TODO we are not covering the case where a elemenent with multiple roles. E.g. role = "form banner". This is a improvment we might want to add in the future.
+                            roleNameTrigger = [
+                                "complementary",
+                                "contentinfo",
+                                "form",
+                                "banner",
+                                "main",
+                                "navigation",
+                                "region",
+                                "search",
+                            ].includes(els[j].getAttribute("role")); // TODO we are not covering the case where a elemenent with multiple roles. E.g. role = "form banner". This is a improvment we might want to add in the future.
                         }
                         if (tagNameTrigger || roleNameTrigger) {
                             // Nearest parent-landmark found
-                            navigationNodesParents.push(els[j])
-                            break
+                            navigationNodesParents.push(els[j]);
+                            break;
                         }
-                        if (j === els.length - 1) { // This node is at the head of the file so it does not have a parent
-                            navigationNodesParents.push(null) // TODO might want to change to NULL
-                            break
+                        if (j === els.length - 1) {
+                            // This node is at the head of the file so it does not have a parent
+                            navigationNodesParents.push(null); // TODO might want to change to NULL
+                            break;
                         }
                     }
                 }
 
                 let navigationNodesComputedLabels = [];
-                for (let i = 0; i < navigationNodes.length; i++) { // Loop over all the landmark nodes
-                    navigationNodesComputedLabels.push(ARIAMapper.computeName(navigationNodes[i]))
+                for (let i = 0; i < navigationNodes.length; i++) {
+                    // Loop over all the landmark nodes
+                    navigationNodesComputedLabels.push(
+                        ARIAMapper.computeName(navigationNodes[i])
+                    );
                 }
-                for (let i = 0; i < navigationNodesParents.length; i++) { // Loop over all the parents of the landmark nodes to find duplicates
+                for (let i = 0; i < navigationNodesParents.length; i++) {
+                    // Loop over all the parents of the landmark nodes to find duplicates
                     let matchFound = false;
                     let pass_0_flag = false;
                     for (let j = 0; j < navigationNodesParents.length; j++) {
                         if (j === i) {
                             // We do not want to compare against ourselfs
-                            continue
+                            continue;
                         }
-                        
+
                         // This if statement focus on the case where the parent landmark is null
-                        if ((navigationNodesParents[i] === null) && (navigationNodesParents[j] === null)) {
+                        if (
+                            navigationNodesParents[i] === null &&
+                            navigationNodesParents[j] === null
+                        ) {
                             // We are looking at two root nodes, so we should compare them.
-                            if (ARIAMapper.nodeToRole(navigationNodes[i]) === ARIAMapper.nodeToRole(navigationNodes[j])) {
+                            if (
+                                ARIAMapper.nodeToRole(navigationNodes[i]) ===
+                                ARIAMapper.nodeToRole(navigationNodes[j])
+                            ) {
                                 // Both nodes have the same role AND
-                                if ((navigationNodesComputedLabels[i] === navigationNodesComputedLabels[j])) {
+                                if (
+                                    navigationNodesComputedLabels[i] ===
+                                    navigationNodesComputedLabels[j]
+                                ) {
                                     // both have the same (computed) aria-label/aria-labelledby
                                     // if (navigationNodesComputedLabels[i] === "") {
-                                        navigationNodesMatchFound.push("Fail_0");  // Fail 0
-                                        matchFound = true
-                                        break
+                                    navigationNodesMatchFound.push("Fail_0"); // Fail 0
+                                    matchFound = true;
+                                    break;
                                     // }
                                 } else {
-                                    // Same parents && same node roles BUT different computed aria-label/aria-labelledby 
+                                    // Same parents && same node roles BUT different computed aria-label/aria-labelledby
                                     // We have at least a Pass_0. But we need to check all nodes to see if another one fails. So set a flag.
-                                    pass_0_flag = true
+                                    pass_0_flag = true;
                                 }
                             } else {
                                 // Same parents but different node roles // Not applicable
                             }
-                        }else if ((navigationNodesParents[i] === null) || (navigationNodesParents[j] === null)) {
+                        } else if (
+                            navigationNodesParents[i] === null ||
+                            navigationNodesParents[j] === null
+                        ) {
                             // We are looking at a single root node
-                            continue
+                            continue;
                         }
 
                         // This if statement focus on the case where the parent landmark is NOT null
-                        if (DOMUtil.sameNode(navigationNodesParents[i], navigationNodesParents[j])) {
-                            // We have the same parent-landmark AND  
-                            if (ARIAMapper.nodeToRole(navigationNodes[i]) === ARIAMapper.nodeToRole(navigationNodes[j])) {
+                        if (
+                            DOMUtil.sameNode(
+                                navigationNodesParents[i],
+                                navigationNodesParents[j]
+                            )
+                        ) {
+                            // We have the same parent-landmark AND
+                            if (
+                                ARIAMapper.nodeToRole(navigationNodes[i]) ===
+                                ARIAMapper.nodeToRole(navigationNodes[j])
+                            ) {
                                 // Both nodes have the same role AND
-                                if ((navigationNodesComputedLabels[i] === navigationNodesComputedLabels[j])) {
+                                if (
+                                    navigationNodesComputedLabels[i] ===
+                                    navigationNodesComputedLabels[j]
+                                ) {
                                     // both have the same (computed) aria-label/aria-labelledby
                                     // if (navigationNodesComputedLabels[i] === "") {
-                                        navigationNodesMatchFound.push("Fail_0");  // Fail 0
-                                        matchFound = true
-                                        break
+                                    navigationNodesMatchFound.push("Fail_0"); // Fail 0
+                                    matchFound = true;
+                                    break;
                                     // }
                                 } else {
-                                    // Same parents && same node roles BUT different computed aria-label/aria-labelledby 
+                                    // Same parents && same node roles BUT different computed aria-label/aria-labelledby
                                     // We have at least a Pass_0. But we need to check all nodes to see if another one fails. So set a flag.
-                                    pass_0_flag = true
+                                    pass_0_flag = true;
                                 }
                             } else {
                                 // Same parents but different node roles // Not applicable
@@ -154,20 +219,23 @@ let a11yRulesLabeling: Rule[] = [
                         }
                     }
                 }
-                formCache.navigationNodesComputedLabels = navigationNodesComputedLabels;
+                formCache.navigationNodesComputedLabels =
+                    navigationNodesComputedLabels;
                 formCache.navigationNodes = navigationNodes;
                 formCache.navigationNodesParents = navigationNodesParents;
                 formCache.navigationNodesMatchFound = navigationNodesMatchFound;
-                RPTUtil.setCache(ruleContext.ownerDocument, "landmark_name_unique", formCache);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "landmark_name_unique",
+                    formCache
+                );
 
                 // TODO Add validation that all 3 arrays are the same length
                 // console.log("-------------End formCache")
-
             } // End formCache
 
             let indexToCheck = -1;
             for (let i = 0; i < formCache.navigationNodes.length; i++) {
-
                 if (ruleContext.isSameNode(formCache.navigationNodes[i])) {
                     indexToCheck = i;
                 }
@@ -175,15 +243,37 @@ let a11yRulesLabeling: Rule[] = [
             if (indexToCheck === -1) {
                 return null;
             }
-            if (formCache.navigationNodesMatchFound[indexToCheck].includes("Pass_0")) {
-                return RulePass(formCache.navigationNodesMatchFound[indexToCheck], [ARIAMapper.nodeToRole(formCache.navigationNodes[indexToCheck])]);
-            } else if (formCache.navigationNodesMatchFound[indexToCheck].includes("Fail_0")) {
-                return RuleFail(formCache.navigationNodesMatchFound[indexToCheck], [ARIAMapper.nodeToRole(formCache.navigationNodes[indexToCheck]), formCache.navigationNodesComputedLabels[indexToCheck]]);
+            if (
+                formCache.navigationNodesMatchFound[indexToCheck].includes(
+                    "Pass_0"
+                )
+            ) {
+                return RulePass(
+                    formCache.navigationNodesMatchFound[indexToCheck],
+                    [
+                        ARIAMapper.nodeToRole(
+                            formCache.navigationNodes[indexToCheck]
+                        ),
+                    ]
+                );
+            } else if (
+                formCache.navigationNodesMatchFound[indexToCheck].includes(
+                    "Fail_0"
+                )
+            ) {
+                return RuleFail(
+                    formCache.navigationNodesMatchFound[indexToCheck],
+                    [
+                        ARIAMapper.nodeToRole(
+                            formCache.navigationNodes[indexToCheck]
+                        ),
+                        formCache.navigationNodesComputedLabels[indexToCheck],
+                    ]
+                );
             } else {
                 return null;
             }
-
-        }
+        },
     },
     {
         /**
@@ -193,14 +283,23 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_RegionLabel_Implicit",
         context: "dom:*[role], dom:section",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             let tagName = ruleContext.tagName.toLowerCase();
 
-            if (tagName === "section" && !RPTUtil.hasRole(ruleContext, "region", false)) {
+            if (
+                tagName === "section" &&
+                !RPTUtil.hasRole(ruleContext, "region", false)
+            ) {
                 return null;
             }
-            if (tagName !== "section" && !RPTUtil.hasRoleInSemantics(ruleContext, "region")) {
+            if (
+                tagName !== "section" &&
+                !RPTUtil.hasRoleInSemantics(ruleContext, "region")
+            ) {
                 return null;
             }
 
@@ -208,10 +307,9 @@ let a11yRulesLabeling: Rule[] = [
             if (passed) {
                 return RulePass("Pass_0");
             } else {
-
                 return RuleFail(tagName === "section" ? "Fail_1" : "Fail_2");
             }
-        }
+        },
     },
     {
         /**
@@ -221,17 +319,33 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleMainsRequireLabel_Implicit_2",
         context: "aria:main",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             let contextLabel = RPTUtil.getAriaLabel(ruleContext);
 
-            let parentDocRole = RPTUtil.getAncestorWithRole(ruleContext, "document", true);
-            let mains = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "main", true, true);
+            let parentDocRole = RPTUtil.getAncestorWithRole(
+                ruleContext,
+                "document",
+                true
+            );
+            let mains = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "main",
+                true,
+                true
+            );
             let result = null;
             for (let i = 0; i < mains.length; ++i) {
                 if (mains[i] === ruleContext) continue;
                 result = RulePass("Pass_0");
-                let thisParentDocRole = RPTUtil.getAncestorWithRole(mains[i], "document", true);
+                let thisParentDocRole = RPTUtil.getAncestorWithRole(
+                    mains[i],
+                    "document",
+                    true
+                );
                 if (thisParentDocRole === parentDocRole) {
                     if (RPTUtil.getAriaLabel(mains[i]) === contextLabel) {
                         result = RuleFail("Fail_1");
@@ -240,7 +354,7 @@ let a11yRulesLabeling: Rule[] = [
                 }
             }
             return result;
-        }
+        },
     },
     {
         /**
@@ -250,13 +364,21 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleMainsVisibleLabel_Implicit",
         context: "dom:body",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
 
             // Consider the Check Hidden Content setting that is set by the rules
-            //call getElementsByRoleHidden with considerImplicit flag as true 
-            //so that the method returs <main> elements 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "main", true, true);
+            //call getElementsByRoleHidden with considerImplicit flag as true
+            //so that the method returs <main> elements
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "main",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
@@ -268,7 +390,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -277,22 +399,39 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleBannerLandmarks_Implicit",
         context: "aria:banner",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "banner", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "banner",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleBannerLandmarks_Implicit", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleBannerLandmarks_Implicit",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleBannerLandmarks_Implicit", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleBannerLandmarks_Implicit",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -300,7 +439,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -309,30 +448,42 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_OneBannerInSiblingSet_Implicit",
         context: "dom:*[role], dom:header",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             if (!RPTUtil.hasRoleInSemantics(ruleContext, "banner")) {
                 return null;
             }
 
-            let passed = RPTUtil.getSiblingWithRoleHidden(ruleContext, "banner", true, true) === null;
+            let passed =
+                RPTUtil.getSiblingWithRoleHidden(
+                    ruleContext,
+                    "banner",
+                    true,
+                    true
+                ) === null;
             //return new ValidationResult(passed, [ruleContext], 'role', '', []);
             if (passed) {
                 return RulePass("Pass_0");
             } else {
                 return RuleFail("Fail_1");
             }
-        }
+        },
     },
     {
         /**
-        * Description: Triggers if a complementary role is not labeled with an aria-label or aria-labelledby
+         * Description: Triggers if a complementary role is not labeled with an aria-label or aria-labelledby
          * also, consider <aside> as this element has implicit 'complementary' role.
          * Origin:  CI162 Web checklist checkpoint 2.4a
-        */
+         */
         id: "Rpt_Aria_ComplementaryRequiredLabel_Implicit",
         context: "dom:*[role], dom:aside",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             if (!RPTUtil.hasRoleInSemantics(ruleContext, "complementary")) {
                 return null;
@@ -345,7 +496,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RuleFail("Fail_1");
             }
-        }
+        },
     },
     {
         /**
@@ -356,46 +507,69 @@ let a11yRulesLabeling: Rule[] = [
         id: "Rpt_Aria_ComplementaryLandmarkLabel_Implicit",
         context: "dom:*[role], dom:aside",
         dependencies: ["Rpt_Aria_ComplementaryRequiredLabel_Implicit"],
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             if (!RPTUtil.hasRoleInSemantics(ruleContext, "complementary")) {
                 return null;
             }
 
-            let passed = RPTUtil.attributeNonEmpty(ruleContext, "aria-labelledby");
+            let passed = RPTUtil.attributeNonEmpty(
+                ruleContext,
+                "aria-labelledby"
+            );
             //return new ValidationResult(passed, [ruleContext], 'role', '', []);
             if (passed) {
                 return RulePass("Pass_0");
             } else {
                 return RuleFail("Fail_1");
             }
-        }
+        },
     },
 
     {
         /**
-         * Description: Triggers if multiple complementary landmarks are present and 
+         * Description: Triggers if multiple complementary landmarks are present and
          * they don't have unique labels.
          * Origin:  CI162 Web checklist checkpoint 2.4a
          */
         id: "Rpt_Aria_MultipleComplementaryLandmarks_Implicit",
         context: "aria:complementary",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "complementary", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "complementary",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleComplementaryLandmarks_Implicit", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleComplementaryLandmarks_Implicit",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleComplementaryLandmarks_Implicit", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleComplementaryLandmarks_Implicit",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -403,7 +577,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
 
     {
@@ -413,22 +587,39 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleContentinfoLandmarks_Implicit",
         context: "aria:contentinfo",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "contentinfo", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "contentinfo",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleContentinfoLandmarks_Implicit", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleContentinfoLandmarks_Implicit",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleContentinfoLandmarks_Implicit", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleContentinfoLandmarks_Implicit",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -436,7 +627,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -446,14 +637,22 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleContentinfoInSiblingSet_Implicit",
         context: "dom:*[role], dom:footer, dom:address",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             //find out if <footer> element has siblings as <footer> has implicit contentinfo role
             if (!RPTUtil.hasRoleInSemantics(ruleContext, "contentinfo")) {
                 return null;
             }
 
-            let passed = !RPTUtil.getSiblingWithRoleHidden(ruleContext, "contentinfo", true, true);
+            let passed = !RPTUtil.getSiblingWithRoleHidden(
+                ruleContext,
+                "contentinfo",
+                true,
+                true
+            );
 
             //return new ValidationResult(passed, [ruleContext], 'role', '', []);
             if (!passed) {
@@ -461,7 +660,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -472,7 +671,10 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_ContentinfoWithNoMain_Implicit",
         context: "dom:*[role], dom:footer, dom:address",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             //consider implicit role
             if (!RPTUtil.hasRoleInSemantics(ruleContext, "contentinfo")) {
@@ -480,7 +682,13 @@ let a11yRulesLabeling: Rule[] = [
             }
 
             // Consider the Check Hidden Content setting that is set by the rules
-            let passed = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "main", true, true).length > 0;
+            let passed =
+                RPTUtil.getElementsByRoleHidden(
+                    ruleContext.ownerDocument,
+                    "main",
+                    true,
+                    true
+                ).length > 0;
 
             //return new ValidationResult(passed, [ruleContext], 'role', '', []);
             if (!passed) {
@@ -488,7 +696,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -497,11 +705,19 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleFormLandmarks",
         context: "dom:body",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
 
             // Consider the Check Hidden Content setting that is set by the rules
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "form", true, true);
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "form",
+                true,
+                true
+            );
             if (landmarks.length === 0) {
                 return null;
             }
@@ -514,7 +730,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass(1);
             }
-        }
+        },
     },
     {
         /**
@@ -523,29 +739,49 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleFormLandmarks_Implicit",
         context: "aria:form",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
 
             // Per https://www.w3.org/TR/2017/NOTE-wai-aria-practices-1.1-20171214/examples/landmarks/HTML5.html
             // form element should only be considered if it has an aria label or title
-            if (ruleContext.getAttribute("role") === "form"
-                || ruleContext.hasAttribute("aria-label")
-                || ruleContext.hasAttribute("aria-labelledby")
-                || ruleContext.hasAttribute("title")) {
+            if (
+                ruleContext.getAttribute("role") === "form" ||
+                ruleContext.hasAttribute("aria-label") ||
+                ruleContext.hasAttribute("aria-labelledby") ||
+                ruleContext.hasAttribute("title")
+            ) {
                 // Consider the Check Hidden Content setting that is set by the rules
-                // Also, consider Implicit role checking. 
-                let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "form", true, true);
+                // Also, consider Implicit role checking.
+                let landmarks = RPTUtil.getElementsByRoleHidden(
+                    ruleContext.ownerDocument,
+                    "form",
+                    true,
+                    true
+                );
                 if (landmarks.length === 0 || landmarks.length === 1) {
                     return null;
                 }
 
-                let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleFormLandmarks_Implicit", null);
+                let dupes = RPTUtil.getCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleFormLandmarks_Implicit",
+                    null
+                );
                 if (!dupes) {
                     dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                    RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleFormLandmarks_Implicit", dupes);
+                    RPTUtil.setCache(
+                        ruleContext.ownerDocument,
+                        "Rpt_Aria_MultipleFormLandmarks_Implicit",
+                        dupes
+                    );
                 }
                 let myLabel = RPTUtil.getAriaLabel(ruleContext);
-                let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+                let passed =
+                    myLabel !== "" &&
+                    (!(myLabel in dupes) || dupes[myLabel] <= 1);
                 if (!passed) {
                     return RuleFail("Fail_1", [myLabel]);
                 } else {
@@ -554,7 +790,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return null;
             }
-        }
+        },
     },
     {
         /**
@@ -563,21 +799,38 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleNavigationLandmarks_Implicit",
         context: "aria:navigation",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "navigation", true, true);
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "navigation",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleNavigationLandmarks_Implicit", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleNavigationLandmarks_Implicit",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleNavigationLandmarks_Implicit", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleNavigationLandmarks_Implicit",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -585,7 +838,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -594,22 +847,39 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleSearchLandmarks",
         context: "aria:search",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
 
             // Consider the Check Hidden Content setting that is set by the rules
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "search", true, true);
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "search",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleSearchLandmarks", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleSearchLandmarks",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleSearchLandmarks", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleSearchLandmarks",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             // return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -617,7 +887,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -627,38 +897,57 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleRegionsUniqueLabel_Implicit",
         context: "aria:region",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Per https://www.w3.org/TR/2017/NOTE-wai-aria-practices-1.1-20171214/examples/landmarks/HTML5.html
             // form element should only be considered if it has an aria label or title
-            if (ruleContext.getAttribute("role") === "region"
-                || ruleContext.hasAttribute("aria-label")
-                || ruleContext.hasAttribute("aria-labelledby")
-                || ruleContext.hasAttribute("title")) {
+            if (
+                ruleContext.getAttribute("role") === "region" ||
+                ruleContext.hasAttribute("aria-label") ||
+                ruleContext.hasAttribute("aria-labelledby") ||
+                ruleContext.hasAttribute("title")
+            ) {
                 // Consider the Check Hidden Content setting that is set by the rules
-                // Also, consider Implicit role checking. 
-                let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "region", true, true);
+                // Also, consider Implicit role checking.
+                let landmarks = RPTUtil.getElementsByRoleHidden(
+                    ruleContext.ownerDocument,
+                    "region",
+                    true,
+                    true
+                );
                 if (landmarks.length === 0 || landmarks.length === 1) {
                     return null;
                 }
 
-                let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleRegionsUniqueLabel_Implicit", null);
+                let dupes = RPTUtil.getCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleRegionsUniqueLabel_Implicit",
+                    null
+                );
                 if (!dupes) {
                     dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                    RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleRegionsUniqueLabel_Implicit", dupes);
+                    RPTUtil.setCache(
+                        ruleContext.ownerDocument,
+                        "Rpt_Aria_MultipleRegionsUniqueLabel_Implicit",
+                        dupes
+                    );
                 }
                 let myLabel = RPTUtil.getAriaLabel(ruleContext);
-                let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+                let passed =
+                    myLabel !== "" &&
+                    (!(myLabel in dupes) || dupes[myLabel] <= 1);
                 if (!passed) {
                     return RuleFail("Fail_1", [myLabel]);
                 } else {
                     return RulePass("Pass_0");
                 }
-
             } else {
                 return null;
             }
-        }
+        },
     },
     {
         /**
@@ -667,7 +956,10 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_ApplicationLandmarkLabel",
         context: "aria:application",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             let passed = RPTUtil.hasAriaLabel(ruleContext);
             // return new ValidationResult(passed, [ruleContext], 'role', '', []);
@@ -676,7 +968,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -685,22 +977,39 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleApplicationLandmarks",
         context: "aria:application",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "application", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "application",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleApplicationLandmarks", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleApplicationLandmarks",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleApplicationLandmarks", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleApplicationLandmarks",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
@@ -708,7 +1017,7 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -717,30 +1026,47 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleDocumentRoles",
         context: "aria:document",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "document", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "document",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleDocumentRoles", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleDocumentRoles",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleDocumentRoles", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleDocumentRoles",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel === "" || (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel === "" || !(myLabel in dupes) || dupes[myLabel] <= 1;
 
-            // return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]); 
+            // return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
                 return RuleFail("Fail_1", [myLabel]);
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
@@ -750,7 +1076,10 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_ArticleRoleLabel_Implicit",
         context: "aria:article",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             let passed = RPTUtil.hasAriaLabel(ruleContext);
             // return new ValidationResult(passed, [ruleContext], 'role', '', []);
@@ -759,51 +1088,71 @@ let a11yRulesLabeling: Rule[] = [
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
     {
         /**
          * Description: Triggers if multiple article roles are present and they don't have unique labels
-         * Also, consider <article> element with implicit article role. 
+         * Also, consider <article> element with implicit article role.
          * Origin:  CI162 Web checklist checkpoint 2.4a
          */
         id: "Rpt_Aria_MultipleArticleRoles_Implicit",
         context: "aria:article",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "article", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "article",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleArticleRoles_Implicit", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleArticleRoles_Implicit",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleArticleRoles_Implicit", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleArticleRoles_Implicit",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel === "" || !(myLabel in dupes) || dupes[myLabel] <= 1;
+            let passed =
+                myLabel === "" || !(myLabel in dupes) || dupes[myLabel] <= 1;
 
-            //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]); 
+            //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
             if (!passed) {
                 return RuleFail("Fail_1", [myLabel]);
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
 
     {
         /**
          * Description: Triggers if a group role is not labeled with an aria-labelledby or aria-label
-         * Also, consider <details> element which has implicit article role. 
+         * Also, consider <details> element which has implicit article role.
          * Origin:  CI162 Web checklist checkpoint 2.4a
          */
         id: "Rpt_Aria_GroupRoleLabel_Implicit",
         context: "dom:*[role], dom:details",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             let roleName = "group";
             if (!RPTUtil.hasRoleInSemantics(ruleContext, roleName)) {
@@ -812,7 +1161,8 @@ let a11yRulesLabeling: Rule[] = [
 
             let passed = RPTUtil.hasAriaLabel(ruleContext);
             if (!passed) {
-                passed = !!RPTUtil.getAncestorWithRole(ruleContext, "menubar") ||
+                passed =
+                    !!RPTUtil.getAncestorWithRole(ruleContext, "menubar") ||
                     !!RPTUtil.getAncestorWithRole(ruleContext, "menu") ||
                     !!RPTUtil.getAncestorWithRole(ruleContext, "tree");
                 if (passed) {
@@ -827,57 +1177,119 @@ let a11yRulesLabeling: Rule[] = [
             retToken2.push(roleName);
             //return new ValidationResult(passed, [ruleContext], 'role', '', passed === true ? [] : [retToken1, retToken2]);
             if (!passed) {
-                return RuleFail("Fail_1", [retToken1.toString(), retToken2.toString()]);
+                return RuleFail("Fail_1", [
+                    retToken1.toString(),
+                    retToken2.toString(),
+                ]);
             } else {
                 return RulePass("Pass_0");
             }
-        }
+        },
     },
+    {
+        /**
+         * Description: Triggers if multiple group roles are present and they don't have unique labels
+         * Also, consider <details> element which has implicit 'group' role
+         * Origin:  CI162 Web checklist checkpoint 2.4a
+         */
+        id: "group_withInputs_hasName",
+        context: "aria:group",
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
+            const ruleContext = context["dom"].node as Element;
+            let ownerDocument = FragmentUtil.getOwnerFragment(ruleContext);
+            let formCache = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "landmark_name_unique",
+                null
+            );
 
-    /** --------------------------------------------------------------------------------------------
-     * DEPRECATED: This rule is being deprecated and replaced by 2 separate rules that are more 
-     * targeted. 
-     * 1) landmark_name_unique
-     * 2) group_withInputs_hasName
-     * The reasoning for this was we were accidentally catching groups that were valid. Such as 
-     * groups that might have the same name but had structurally ways to reach them. So they were 
-     * disambiguated by structure nested parent hierarchy.
-     * --------------------------------------------------------------------------------------------
-     * Description: Triggers if multiple group roles are present and they don't have unique labels
-     * Also, consider <details> element which has implicit 'group' role
-     * Origin:  CI162 Web checklist checkpoint 2.4a
-     */
-    // {
-    //     id: "Rpt_Aria_MultipleGroupRoles_Implicit",
-    //     context: "aria:group",
-    //     run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
-    //         const ruleContext = context["dom"].node as Element;
-
-    //         // Consider the Check Hidden Content setting that is set by the rules
-    //         // Also, consider Implicit role checking. 
-    //         let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "group", true, true);
-    //         if (landmarks.length === 0 || landmarks.length === 1) {
-    //             return null;
-    //         }
-
-    //         let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleGroupRoles_Implicit", null);
-    //         if (!dupes) {
-    //             dupes = RPTUtil.findAriaLabelDupes(landmarks);
-    //             RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleGroupRoles_Implicit", dupes);
-    //         }
-    //         let myLabel = RPTUtil.getAriaLabel(ruleContext);
-    //         let passed = myLabel === "" || !(myLabel in dupes) || dupes[myLabel] <= 1;
-
-    //         //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
-    //         if (!passed) {
-    //             return RuleFail("Fail_1", [myLabel]);
-    //         } else {
-    //             return RulePass("Pass_0");
-    //         }
-    //     }
-    // },
-
+            if (!formCache) {
+                formCache = {
+                    groupsWithInputs: [],
+                    groupsWithInputsComputedLabels: [],
+                };
+                let allGroupsTemp = ownerDocument.querySelectorAll(
+                    'fieldset,[role="group"]'
+                );
+                let allGroups = Array.from(allGroupsTemp);
+                let groupsWithInputs = [];
+                for (let i = 0; i < allGroups.length; i++) {
+                    // Loop over all the group nodes
+                    if (allGroups[i].querySelector("input")) {
+                        groupsWithInputs.push(allGroups[i]);
+                    }
+                }
+                let groupsWithInputsComputedLabels = [];
+                for (let i = 0; i < groupsWithInputs.length; i++) {
+                    // Loop over all the landmark nodes
+                    groupsWithInputsComputedLabels.push(
+                        ARIAMapper.computeName(groupsWithInputs[i])
+                    );
+                }
+                formCache.groupsWithInputs = groupsWithInputs;
+                formCache.groupsWithInputsComputedLabels =
+                    groupsWithInputsComputedLabels;
+            }
+            // formCache.groupsWithInputs.forEach(element => {
+            //     console.log("formCache.groupsWithInputs: " +element.id)
+            // });
+            // console.log("formCache.groupsWithInputsComputedLabels: " +formCache.groupsWithInputsComputedLabels)
+            // console.log("formCache.groupsWithInputsComputedLabels: " +formCache.groupsWithInputsComputedLabels.length)
+
+            let ruleContextFoundIngroupsWithInputsFlag = false;
+            let computedName = "";
+            if (!formCache.groupsWithInputs) {
+                // We do not have any groups with inputs. Therefore we should skip this rule trigger.
+                return null;
+            }
 
+            for (let i = 0; i < formCache.groupsWithInputs.length; i++) {
+                if (ruleContext.isSameNode(formCache.groupsWithInputs[i])) {
+                    // We have found our ruleContext in the cache
+                    ruleContextFoundIngroupsWithInputsFlag = true;
+                    if (
+                        formCache.groupsWithInputsComputedLabels[i] === "" ||
+                        formCache.groupsWithInputsComputedLabels[i] === null
+                    ) {
+                        // console.log("Fail_1")
+                        return RuleFail("Fail_1");
+                    }
+                    let foundSameNameFlag = false;
+                    for (
+                        let j = 0;
+                        j < formCache.groupsWithInputsComputedLabels.length;
+                        j++
+                    ) {
+                        if (i == j) {
+                            continue;
+                        } // We do not want to compare against ourselfs
+                        if (
+                            formCache.groupsWithInputsComputedLabels[i] ===
+                            formCache.groupsWithInputsComputedLabels[j]
+                        ) {
+                            foundSameNameFlag = true;
+                        }
+                    }
+                    if (foundSameNameFlag) {
+                        // console.log("Fail_2")
+                        return RuleFail("Fail_2", [
+                            formCache.groupsWithInputsComputedLabels[i],
+                        ]);
+                    }
+                    computedName = formCache.groupsWithInputsComputedLabels[i];
+                }
+            }
+            if (!ruleContextFoundIngroupsWithInputsFlag) {
+                // console.log("null return")
+                return null;
+            }
+            // console.log("Pass_1")
+            return RulePass("Pass_1", [computedName]);
+        }
+    },
     {
         /**
          * Description: Triggers if a WAI-ARIA widget does not have an accessible name via an ARIA label or inner text
@@ -886,13 +1298,22 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_WidgetLabels_Implicit",
         context: "dom:*",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             /* removed the role check role= presentation and role=none since these 2 roles are not in the list of widget type roles */
-            if ((ruleContext.hasAttribute("type") && ruleContext.getAttribute("type") === "hidden")
-                || (RPTUtil.getAncestorWithRole(ruleContext, "combobox") &&
-                    !(RPTUtil.hasRoleInSemantics(ruleContext, "textbox") ||
-                        RPTUtil.hasRoleInSemantics(ruleContext, "searchbox")))) { // we need to diagnose that a combobox input textbox has a label(github issue #1104) 
+            if (
+                (ruleContext.hasAttribute("type") &&
+                    ruleContext.getAttribute("type") === "hidden") ||
+                (RPTUtil.getAncestorWithRole(ruleContext, "combobox") &&
+                    !(
+                        RPTUtil.hasRoleInSemantics(ruleContext, "textbox") ||
+                        RPTUtil.hasRoleInSemantics(ruleContext, "searchbox")
+                    ))
+            ) {
+                // we need to diagnose that a combobox input textbox has a label(github issue #1104)
                 return null;
             }
 
@@ -900,19 +1321,48 @@ let a11yRulesLabeling: Rule[] = [
             let tagName = ruleContext.nodeName.toLowerCase();
 
             // Handled by WCAG20_Input_ExplicitLabel
-            let skipRoles = ["button", "checkbox", "combobox",
-                "listbox", "menuitemcheckbox", "menuitemradio", "radio", "searchbox",
-                "slider", "spinbutton", "switch", "textbox", "progressbar", "link"
-            ]
+            let skipRoles = [
+                "button",
+                "checkbox",
+                "combobox",
+                "listbox",
+                "menuitemcheckbox",
+                "menuitemradio",
+                "radio",
+                "searchbox",
+                "slider",
+                "spinbutton",
+                "switch",
+                "textbox",
+                "progressbar",
+                "link",
+            ];
             if (skipRoles.includes(elemRole)) return null;
-            if (tagName === "output"
-                || tagName === "input" && ruleContext.getAttribute("type") === "file") {
-
+            if (
+                tagName === "output" ||
+                (tagName === "input" &&
+                    ruleContext.getAttribute("type") === "file")
+            ) {
             }
             if (!ruleContext.hasAttribute("role")) {
                 // Form/input elements are checked by G41, we skip them from this rule. Github issue 449
-                let skipElements = ["input", "textarea", "select", "button", "datalist", "optgroup", "option", "keygen", "output", "progress", "meter"];
-                if (skipElements.indexOf(ruleContext.nodeName.toLowerCase()) != -1) {
+                let skipElements = [
+                    "input",
+                    "textarea",
+                    "select",
+                    "button",
+                    "datalist",
+                    "optgroup",
+                    "option",
+                    "keygen",
+                    "output",
+                    "progress",
+                    "meter",
+                ];
+                if (
+                    skipElements.indexOf(ruleContext.nodeName.toLowerCase()) !=
+                    -1
+                ) {
                     return null;
                 }
             }
@@ -921,14 +1371,27 @@ let a11yRulesLabeling: Rule[] = [
             let rolesToCheck = ["listbox", "tree", "grid", "dialog"];
             for (let j = 0; j < rolesToCheck.length; j++) {
                 if (RPTUtil.hasRoleInSemantics(ruleContext, rolesToCheck[j])) {
-                    let comboboxes = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "combobox", true, true);
+                    let comboboxes = RPTUtil.getElementsByRoleHidden(
+                        ruleContext.ownerDocument,
+                        "combobox",
+                        true,
+                        true
+                    );
                     for (let k = 0; k < comboboxes.length; k++) {
                         let combobox = comboboxes[k];
-                        let aria_owns = RPTUtil.getElementAttribute(combobox, "aria-owns");
+                        let aria_owns = RPTUtil.getElementAttribute(
+                            combobox,
+                            "aria-owns"
+                        );
                         if (aria_owns) {
-                            let owns = RPTUtil.normalizeSpacing(aria_owns.trim()).split(" ");
+                            let owns = RPTUtil.normalizeSpacing(
+                                aria_owns.trim()
+                            ).split(" ");
                             for (let i = 0; i < owns.length; i++) {
-                                let owned = FragmentUtil.getById(ruleContext, owns[i]);
+                                let owned = FragmentUtil.getById(
+                                    ruleContext,
+                                    owns[i]
+                                );
                                 if (owned === ruleContext) {
                                     return null;
                                 }
@@ -946,33 +1409,49 @@ let a11yRulesLabeling: Rule[] = [
             let numWidgetsTested = 0;
             let interactiveRoleTypes = ["widget", "liveRegion", "window"];
             for (let i = 0, length = roles.length; passed && i < length; ++i) {
-
                 let pattern = designPatterns[roles[i]];
 
-                if (pattern
-                    && pattern.nameRequired
-                    && pattern.roleType
-                    && interactiveRoleTypes.includes(pattern.roleType)) {
+                if (
+                    pattern &&
+                    pattern.nameRequired &&
+                    pattern.roleType &&
+                    interactiveRoleTypes.includes(pattern.roleType)
+                ) {
                     ++numWidgetsTested;
 
                     // All widgets may have an author supplied accessible name.
                     // Title is legal, but don't advertise its use in documentation.
                     // Encourage use of aria-label, aria-labelledby or html label element.
-                    passed = RPTUtil.hasAriaLabel(ruleContext) || RPTUtil.attributeNonEmpty(ruleContext, "title") || RPTUtil.getLabelForElementHidden(ruleContext, true);
-
-                    if (!passed && pattern.nameFrom && pattern.nameFrom.indexOf("contents") >= 0) {
-
+                    passed =
+                        RPTUtil.hasAriaLabel(ruleContext) ||
+                        RPTUtil.attributeNonEmpty(ruleContext, "title") ||
+                        RPTUtil.getLabelForElementHidden(ruleContext, true);
+
+                    if (
+                        !passed &&
+                        pattern.nameFrom &&
+                        pattern.nameFrom.indexOf("contents") >= 0
+                    ) {
                         // See if widget's accessible name is supplied by element's inner text
                         // nameFrom: ["author", "contents"]
                         passed = RPTUtil.hasInnerContentOrAlt(ruleContext);
                     }
 
-                    if (!passed) { // check if it has implicit label, like <label><input ....>abc </label>
+                    if (!passed) {
+                        // check if it has implicit label, like <label><input ....>abc </label>
                         passed = RPTUtil.hasImplicitLabel(ruleContext);
                     }
 
-                    if (!passed && ruleContext.tagName.toLowerCase() === "img" && !ruleContext.hasAttribute("role") && ruleContext.hasAttribute("alt")) {
-                        passed = DOMUtil.cleanWhitespace(ruleContext.getAttribute("alt")).trim().length > 0;
+                    if (
+                        !passed &&
+                        ruleContext.tagName.toLowerCase() === "img" &&
+                        !ruleContext.hasAttribute("role") &&
+                        ruleContext.hasAttribute("alt")
+                    ) {
+                        passed =
+                            DOMUtil.cleanWhitespace(
+                                ruleContext.getAttribute("alt")
+                            ).trim().length > 0;
                     }
 
                     if (pattern.nameFrom.indexOf("prohibited") >= 0) {
@@ -993,7 +1472,7 @@ let a11yRulesLabeling: Rule[] = [
                 return RulePass("Pass_0");
                 //                }
             }
-        }
+        },
     },
 
     {
@@ -1004,31 +1483,95 @@ let a11yRulesLabeling: Rule[] = [
          */
         id: "Rpt_Aria_MultipleToolbarUniqueLabel",
         context: "aria:toolbar",
-        run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+        run: (
+            context: RuleContext,
+            options?: {}
+        ): RuleResult | RuleResult[] => {
             const ruleContext = context["dom"].node as Element;
             // Consider the Check Hidden Content setting that is set by the rules
-            // Also, consider Implicit role checking. 
-            let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "toolbar", true, true);
+            // Also, consider Implicit role checking.
+            let landmarks = RPTUtil.getElementsByRoleHidden(
+                ruleContext.ownerDocument,
+                "toolbar",
+                true,
+                true
+            );
             if (landmarks.length === 0 || landmarks.length === 1) {
                 return null;
             }
 
-            let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleToolbarUniqueLabel", null);
+            let dupes = RPTUtil.getCache(
+                ruleContext.ownerDocument,
+                "Rpt_Aria_MultipleToolbarUniqueLabel",
+                null
+            );
             if (!dupes) {
                 dupes = RPTUtil.findAriaLabelDupes(landmarks);
-                RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleToolbarUniqueLabel", dupes);
+                RPTUtil.setCache(
+                    ruleContext.ownerDocument,
+                    "Rpt_Aria_MultipleToolbarUniqueLabel",
+                    dupes
+                );
             }
             let myLabel = RPTUtil.getAriaLabel(ruleContext);
-            let passed = myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
+            let passed =
+                myLabel !== "" && (!(myLabel in dupes) || dupes[myLabel] <= 1);
 
             if (!passed) {
                 return RuleFail("Fail_1", [myLabel]);
             } else {
                 return RulePass("Pass_0");
             }
-        }
-    }
-
-
-]
-export { a11yRulesLabeling }
+        },
+    },
+];
+/** --------------------------------------------------------------------------------------------
+ * Section for DEPRECATED rules
+ * - This was added as commenting a rule in the JSON structure above was causing
+ * --------------------------------------------------------------------------------------------
+*/
+
+/** --------------------------------------------------------------------------------------------
+ * DEPRECATED: This rule is being deprecated and replaced by 2 separate rules that are more 
+ * targeted. 
+ * 1) landmark_name_unique
+ * 2) group_withInputs_hasName
+ * The reasoning for this was we were accidentally catching groups that were valid. Such as 
+ * groups that might have the same name but had structurally ways to reach them. So they were 
+ * disambiguated by structure nested parent hierarchy.
+ * --------------------------------------------------------------------------------------------
+ * Description: Triggers if multiple group roles are present and they don't have unique labels
+ * Also, consider <details> element which has implicit 'group' role
+ * Origin:  CI162 Web checklist checkpoint 2.4a
+ */
+// {
+//     id: "Rpt_Aria_MultipleGroupRoles_Implicit",
+//     context: "aria:group",
+//     run: (context: RuleContext, options?: {}): RuleResult | RuleResult[] => {
+//         const ruleContext = context["dom"].node as Element;
+//
+//         // Consider the Check Hidden Content setting that is set by the rules
+//         // Also, consider Implicit role checking. 
+//         let landmarks = RPTUtil.getElementsByRoleHidden(ruleContext.ownerDocument, "group", true, true);
+//         if (landmarks.length === 0 || landmarks.length === 1) {
+//             return null;
+//         }
+//
+//         let dupes = RPTUtil.getCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleGroupRoles_Implicit", null);
+//         if (!dupes) {
+//             dupes = RPTUtil.findAriaLabelDupes(landmarks);
+//             RPTUtil.setCache(ruleContext.ownerDocument, "Rpt_Aria_MultipleGroupRoles_Implicit", dupes);
+//         }
+//         let myLabel = RPTUtil.getAriaLabel(ruleContext);
+//         let passed = myLabel === "" || !(myLabel in dupes) || dupes[myLabel] <= 1;
+//
+//         //return new ValidationResult(passed, ruleContext, '', '', [ myLabel ]);
+//         if (!passed) {
+//             return RuleFail("Fail_1", [myLabel]);
+//         } else {
+//             return RulePass("Pass_0");
+//         }
+//     }
+// },
+
+export { a11yRulesLabeling };
diff --git a/accessibility-checker-engine/src/v2/checker/accessibility/rulesets/index.ts b/accessibility-checker-engine/src/v2/checker/accessibility/rulesets/index.ts
index b5c69f30b..a84dd2f3e 100644
--- a/accessibility-checker-engine/src/v2/checker/accessibility/rulesets/index.ts
+++ b/accessibility-checker-engine/src/v2/checker/accessibility/rulesets/index.ts
@@ -257,6 +257,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Information, structure, and relationships conveyed through presentation can be programmatically determined or are available in text.",
             "rules": [
+                {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "landmark_name_unique",
                     level: eRulePolicy.VIOLATION,
@@ -1025,6 +1030,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Labels or instructions are provided when content requires user input.",
             "rules": [
+                {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "WCAG20_Input_LabelBefore",
                     level: eRulePolicy.VIOLATION,
@@ -1459,6 +1469,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Information, structure, and relationships conveyed through presentation can be programmatically determined or are available in text.",
             "rules": [
+                 {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "landmark_name_unique",
                     level: eRulePolicy.RECOMMENDATION,
@@ -2215,6 +2230,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Labels or instructions are provided when content requires user input.",
             "rules": [
+                 {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "WCAG20_Input_LabelBefore",
                     level: eRulePolicy.VIOLATION,
@@ -2649,6 +2669,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Information, structure, and relationships conveyed through presentation can be programmatically determined or are available in text.",
             "rules": [
+                 {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "landmark_name_unique",
                     level: eRulePolicy.RECOMMENDATION,
@@ -3317,6 +3342,11 @@ let a11yRulesets: Ruleset[] = [
             "wcagLevel": "A",
             "summary": "Labels or instructions are provided when content requires user input.",
             "rules": [
+                {
+                    id: "group_withInputs_hasName",
+                    level: eRulePolicy.VIOLATION,
+                    toolkitLevel: eToolkitLevel.LEVEL_THREE
+                },
                 {
                     id: "WCAG20_Input_LabelBefore",
                     level: eRulePolicy.VIOLATION,
diff --git a/accessibility-checker-engine/test/v2/checker/accessibility/rules/group_withInputs_hasName_ruleunit/test_mixed_1.html b/accessibility-checker-engine/test/v2/checker/accessibility/rules/group_withInputs_hasName_ruleunit/test_mixed_1.html
new file mode 100644
index 000000000..c3d333396
--- /dev/null
+++ b/accessibility-checker-engine/test/v2/checker/accessibility/rules/group_withInputs_hasName_ruleunit/test_mixed_1.html
@@ -0,0 +1,470 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--
+   /******************************************************************************
+     Copyright:: 2021- IBM, Inc
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+  *****************************************************************************/
+-->
+
+<html lang="en-US">
+
+<head>
+</head>
+
+<body id="body">
+    <!-- FAIL we have two fieldset with inputs that have the same label in this case: "Choose your favorite monster duplicate" -->
+    <form>
+        <fieldset>
+            <legend>Choose your favorite monster duplicate</legend>
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+        <fieldset>
+            <legend>Choose your favorite monster duplicate</legend>
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+    </form>
+
+    <!-- FAIL we have two fieldset with inputs that have the same label in this case: "testing fieldsets duplicate" -->
+    <form>
+        <fieldset aria-label="testing fieldsets duplicate">
+            <!-- <legend>Choose your favorite monster</legend> -->
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+        <fieldset aria-label="testing fieldsets duplicate">
+            <!-- <legend>Choose your favorite monster</legend> -->
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+    </form>
+
+    <!-- FAIL we have two groups with inputs that have the same label in this case: "testset123" -->
+    <div role="group" aria-label="vehiclesThatIDontOwn">
+        <input type="checkbox" id="vehicle1" name="vehicle1" value="Bike">
+        <label for="vehicle1"> I have a bike1</label><br>
+        <input type="checkbox" id="vehicle2" name="vehicle2" value="Car">
+        <label for="vehicle2"> I have a car</label><br>
+        <input type="checkbox" id="vehicle3" name="vehicle3" value="Boat">
+        <label for="vehicle3"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+    <div role="group" aria-label="vehiclesThatIDontOwn">
+        <input type="checkbox" id="vehicle4" name="vehicle4" value="Bike">
+        <label for="vehicle4"> I have a bike2</label><br>
+        <input type="checkbox" id="vehicle5" name="vehicle5" value="Car">
+        <label for="vehicle5"> I have a car</label><br>
+        <input type="checkbox" id="vehicle6" name="vehicle6" value="Boat">
+        <label for="vehicle6"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+
+
+    <!-- FAIL we have two groups with inputs that have the same label in this case: "testset123" -->
+    <div role="group" aria-labelledby="test_vehicle_123">
+        <div id="test_vehicle_123">testset123</div>
+        <input type="checkbox" id="vehicle1" name="vehicle1" value="Bike">
+        <label for="vehicle1"> I have a bike1</label><br>
+        <input type="checkbox" id="vehicle2" name="vehicle2" value="Car">
+        <label for="vehicle2"> I have a car</label><br>
+        <input type="checkbox" id="vehicle3" name="vehicle3" value="Boat">
+        <label for="vehicle3"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+    <div role="group" aria-labelledby="test_vehicle_456">
+        <div id="test_vehicle_456">testset123</div>
+        <input type="checkbox" id="vehicle4" name="vehicle4" value="Bike">
+        <label for="vehicle4"> I have a bike2</label><br>
+        <input type="checkbox" id="vehicle5" name="vehicle5" value="Car">
+        <label for="vehicle5"> I have a car</label><br>
+        <input type="checkbox" id="vehicle6" name="vehicle6" value="Boat">
+        <label for="vehicle6"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+
+    <!-- FAIL - becase the role=group does not have a label  -->
+    <div role="group" id="test">
+        <input type="checkbox" id="vehicle1" name="vehicle1" value="Bike">
+        <label for="vehicle1"> I have a bike</label><br>
+        <input type="checkbox" id="vehicle2" name="vehicle2" value="Car">
+        <label for="vehicle2"> I have a car</label><br>
+        <input type="checkbox" id="vehicle3" name="vehicle3" value="Boat">
+        <label for="vehicle3"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+
+    <!-- PASS - each group is labeled and each group label is unique -->
+    <div role="group" aria-label="vehicle_123">
+        <div id="vehicle_123">testset123</div>
+        <input type="checkbox" id="vehicle1" name="vehicle1" value="Bike">
+        <label for="vehicle1"> I have a bike1</label><br>
+        <input type="checkbox" id="vehicle2" name="vehicle2" value="Car">
+        <label for="vehicle2"> I have a car</label><br>
+        <input type="checkbox" id="vehicle3" name="vehicle3" value="Boat">
+        <label for="vehicle3"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+    <div role="group" aria-label="vehicle_456">
+        <div id="vehicle_456">testset456</div>
+        <input type="checkbox" id="vehicle4" name="vehicle4" value="Bike">
+        <label for="vehicle4"> I have a bike2</label><br>
+        <input type="checkbox" id="vehicle5" name="vehicle5" value="Car">
+        <label for="vehicle5"> I have a car</label><br>
+        <input type="checkbox" id="vehicle6" name="vehicle6" value="Boat">
+        <label for="vehicle6"> I have a boat</label><br><br>
+        <input type="submit" value="Submit">
+    </div>
+
+    <!-- Netural (No pass/fail) do not report anything since no input -->
+    <div role="group" aria-label="vehicle_789">
+        <div id="vehicle_789">testset789</div>
+    </div>
+
+    <!-- FAIL - becase the fieldset does not have a label/legend  -->
+    <form>
+        <fieldset>
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+    </form>
+
+    <!-- PASS - becase the fieldset does have a legend  -->
+    <form>
+        <fieldset>
+            <legend>Choose your favorite monster</legend>
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+    </form>
+
+    <!-- PASS - becase the fieldset does have a accessibleName  -->
+    <form>
+        <fieldset aria-label="testing fieldsets">
+            <!-- <legend>Choose your favorite monster</legend> -->
+            <input type="radio" id="kraken" name="monster">
+            <label for="kraken">Kraken</label><br />
+
+            <input type="radio" id="sasquatch" name="monster">
+            <label for="sasquatch">Sasquatch</label><br />
+
+            <input type="radio" id="mothman" name="monster">
+            <label for="mothman">Mothman</label>
+        </fieldset>
+    </form>
+
+    <!-- Netural/NO Pass/No Fail - becase the fieldset does not have a input  -->
+    <form>
+        <fieldset aria-label="testing fieldsets">
+            <!-- <legend>Choose your favorite monster</legend> -->
+            <div>Nothing to see here</div>
+        </fieldset>
+    </form>
+
+
+    <script>
+        UnitTest = {
+            ruleIds: ["group_withInputs_hasName"],
+            results: [
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[1]/fieldset[1]",
+                        "aria": "/document[1]/group[1]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"Choose your favorite monster duplicate\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "Choose your favorite monster duplicate"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[1]/fieldset[2]",
+                        "aria": "/document[1]/group[2]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"Choose your favorite monster duplicate\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "Choose your favorite monster duplicate"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[2]/fieldset[1]",
+                        "aria": "/document[1]/group[3]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"testing fieldsets duplicate\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "testing fieldsets duplicate"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[2]/fieldset[2]",
+                        "aria": "/document[1]/group[4]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"testing fieldsets duplicate\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "testing fieldsets duplicate"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[1]",
+                        "aria": "/document[1]/group[5]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"vehiclesThatIDontOwn\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "vehiclesThatIDontOwn"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[2]",
+                        "aria": "/document[1]/group[6]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"vehiclesThatIDontOwn\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "vehiclesThatIDontOwn"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[3]",
+                        "aria": "/document[1]/group[7]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"testset123\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "testset123"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[4]",
+                        "aria": "/document[1]/group[8]"
+                    },
+                    "reasonId": "Fail_2",
+                    "message": "Group/Fieldset \"testset123\" has a duplicate name to another group",
+                    "messageArgs": [
+                        "testset123"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[5]",
+                        "aria": "/document[1]/group[9]"
+                    },
+                    "reasonId": "Fail_1",
+                    "message": "Group/Fieldset does not have an accessible name",
+                    "messageArgs": [],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "PASS"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[6]",
+                        "aria": "/document[1]/group[10]"
+                    },
+                    "reasonId": "Pass_1",
+                    "message": "Group/Fieldset \"vehicle_123\" with an input has a unique name",
+                    "messageArgs": [
+                        "vehicle_123"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "PASS"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/div[7]",
+                        "aria": "/document[1]/group[11]"
+                    },
+                    "reasonId": "Pass_1",
+                    "message": "Group/Fieldset \"vehicle_456\" with an input has a unique name",
+                    "messageArgs": [
+                        "vehicle_456"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "FAIL"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[3]/fieldset[1]",
+                        "aria": "/document[1]/group[13]"
+                    },
+                    "reasonId": "Fail_1",
+                    "message": "Group/Fieldset does not have an accessible name",
+                    "messageArgs": [],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "PASS"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[4]/fieldset[1]",
+                        "aria": "/document[1]/group[14]"
+                    },
+                    "reasonId": "Pass_1",
+                    "message": "Group/Fieldset \"Choose your favorite monster\" with an input has a unique name",
+                    "messageArgs": [
+                        "Choose your favorite monster"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                },
+                {
+                    "ruleId": "group_withInputs_hasName",
+                    "value": [
+                        "INFORMATION",
+                        "PASS"
+                    ],
+                    "path": {
+                        "dom": "/html[1]/body[1]/form[5]/fieldset[1]",
+                        "aria": "/document[1]/group[15]"
+                    },
+                    "reasonId": "Pass_1",
+                    "message": "Group/Fieldset \"testing fieldsets\" with an input has a unique name",
+                    "messageArgs": [
+                        "testing fieldsets"
+                    ],
+                    "apiArgs": [],
+                    "category": "Accessibility"
+                }
+            ]
+
+        }
+    </script>
+</body>
+
+</html>
\ No newline at end of file