@Override
  protected void setProcess() {
    ProcessResult pr = processPageTest("Rgaa32016.Test.12.05.03-4NA-01");
    assertTrue(pr instanceof IndefiniteResult);
    assertEquals(getWebResourceMap().get("Rgaa32016.Test.12.05.03-4NA-01"), pr.getSubject());
    assertEquals("mock-result", pr.getValue());

    process("Rgaa32016.Test.12.05.03-5NT-01");
  }
Exemple #2
0
 @Override
 protected void setProcess() {
   ProcessResult processResult = processPageTest("Aw21.Test.5.3.1-3NMI-01");
   assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
   assertEquals(
       "ManualCheckOnElements",
       ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
   assertEquals(TestSolution.NOT_APPLICABLE, processPageTest("Aw21.Test.5.3.1-4NA-01").getValue());
 }
Exemple #3
0
  @Override
  protected void setProcess() {
    ProcessResult processResult = processPageTest("AW21.Test.11.06.01-1Passed-01");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.06.01-2Failed-01");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        Aw21Rule11061.ERROR_MESSAGE_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.06.01-4NA-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());
  }
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------1Passed-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("Rgaa22.Test.10.1-1Passed-01");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.10.1-1Passed-02");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(2, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-01------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.10.1-2Failed-01");
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    assertTrue(processResult.getRemarkSet().iterator().next() instanceof ProcessRemark);
    assertEquals(
        RemarkMessageStore.H1_TAG_MISSING_MSG,
        processResult.getRemarkSet().iterator().next().getMessageCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.10.1-2Failed-02");
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    assertTrue(processResult.getRemarkSet().iterator().next() instanceof ProcessRemark);
    assertEquals(
        RemarkMessageStore.H1_TAG_MISSING_MSG,
        processResult.getRemarkSet().iterator().next().getMessageCode());
  }
Exemple #5
0
  @Override
  protected void setProcess() {
    ProcessResult processResult = processPageTest("AW21.Test.11.01.02-1Passed-01");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-02");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-03");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-04");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-05");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-06");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-07");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-08");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-09");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-10");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-11");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-12");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-13");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-1Passed-14");
    assertEquals(TestSolution.PASSED, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-01");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-02");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-03");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-04");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-05");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-06");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-07");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_MISSING_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-08");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-09");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-10");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-11");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-12");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-13");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-2Failed-14");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(
        FormRulesHandler.ID_NOT_UNIQUE_MSG_CODE,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(1, processResult.getRemarkSet().size());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-07");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW21.Test.11.01.02-4NA-08");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());
  }
  @Override
  protected void
      setProcess() { // ----------------------------------------------------------------------
    // ------------------------------3NMI-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("Rgaa22.Test.12.3-3NMI-01");
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check test has no remark
    assertNotNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(3, processResult.getElementCounter());
    // check type of remarks and their value
    assertNotNull(processResult.getRemarkSet());
    SourceCodeRemark processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(MANUAL_CHECK_ON_ELEMENTS_MSG, processRemark.getMessageCode());
    // check number, type and value of remarks
    assertNotNull(processResult.getRemarkSet());
    assertEquals(3, processResult.getRemarkSet().size());

    for (ProcessRemark remark : processResult.getRemarkSet()) {
      processRemark = (SourceCodeRemark) remark;
      assertEquals(MANUAL_CHECK_ON_ELEMENTS_MSG, processRemark.getMessageCode());
    }

    // ----------------------------------------------------------------------
    // ------------------------------4NA-01------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.12.3-4NA-01");
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
  }
Exemple #7
0
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ---------------------------2Failed-01---------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("AW22.Test.8.9.1-2Failed-01");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    SourceCodeRemark sourceCodeRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, sourceCodeRemark.getIssue());
    assertEquals(RemarkMessageStore.LINK_WITHOUT_TARGET_MSG, sourceCodeRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, sourceCodeRemark.getTarget());
    assertNotNull(sourceCodeRemark.getSnippet());
    assertNull(sourceCodeRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------2Failed-02---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-2Failed-02");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    sourceCodeRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, sourceCodeRemark.getIssue());
    assertEquals(RemarkMessageStore.LINK_WITHOUT_TARGET_MSG, sourceCodeRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, sourceCodeRemark.getTarget());
    assertNotNull(sourceCodeRemark.getSnippet());
    assertNull(sourceCodeRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------2Failed-03---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-2Failed-03");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    sourceCodeRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, sourceCodeRemark.getIssue());
    assertEquals(
        RemarkMessageStore.FIELDSET_NOT_WITHIN_FORM_MSG, sourceCodeRemark.getMessageCode());
    assertEquals(HtmlElementStore.FIELDSET_ELEMENT, sourceCodeRemark.getTarget());
    assertNotNull(sourceCodeRemark.getSnippet());
    assertNull(sourceCodeRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------2Failed-04---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-2Failed-04");
    // check number of elements in the page
    assertEquals(13, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    sourceCodeRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, sourceCodeRemark.getIssue());
    assertEquals(
        RemarkMessageStore.FIELDSET_NOT_WITHIN_FORM_MSG, sourceCodeRemark.getMessageCode());
    assertEquals(HtmlElementStore.FIELDSET_ELEMENT, sourceCodeRemark.getTarget());
    assertNotNull(sourceCodeRemark.getSnippet());
    assertNull(sourceCodeRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-03---------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-01");
    // check number of elements in the page
    assertEquals(11, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    ProcessRemark processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-02------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-02");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-03------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-03");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-04------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-04");
    // check number of elements in the page
    assertEquals(12, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-05------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-05");
    // check number of elements in the page
    assertEquals(13, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-06------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-06");
    // check number of elements in the page
    assertEquals(13, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ---------------------------3NMI-07------------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.8.9.1-3NMI-07");
    // check number of elements in the page
    assertEquals(13, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark = processResult.getRemarkSet().iterator().next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        getMessageKey(RemarkMessageStore.NO_PATTERN_DETECTED_MSG), processRemark.getMessageCode());
    assertNull(processRemark.getElementList());
  }
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------1Passed-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("Rgaa22.Test.9.3-1Passed-01");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-02");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-03------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-03");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-04------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-04");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-05------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-05");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-06------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-06");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-07------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-07");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-08------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-08");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-09------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-09");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-10------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-10");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-11------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-11");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-12------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-12");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-13------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-13");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-14------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-14");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-15------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-1Passed-15");
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-01------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-2Failed-01");
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    ProcessRemark processRemark =
        ((ProcessRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(RemarkMessageStore.INVALID_DOCTYPE_MSG, processRemark.getMessageCode());
    // check number of evidence elements and their value
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-2Failed-02");
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((ProcessRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(RemarkMessageStore.INVALID_DOCTYPE_MSG, processRemark.getMessageCode());
    // check number of evidence elements and their value
    assertNull(processRemark.getElementList());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-01------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.9.3-4NA-01");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page (no counter management here,
    // we test the presence of one tag in the page)
    assertEquals(0, processResult.getElementCounter());
  }
Exemple #9
0
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------1Passed-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("AW22.Test.06.06.01-1Passed-01");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-1Passed-02");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-03------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-1Passed-03");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-04------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-1Passed-04");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------1Passed-05------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-1Passed-05");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.PASSED, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-01------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-01");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    SourceCodeRemark processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.EMPTY_LINK_MSG, processRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, processRemark.getTarget());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    assertTrue(
        processRemark.getElementList().iterator().next().getValue().contains("my-link.html"));
    assertEquals(
        AttributeStore.HREF_ATTR,
        processRemark.getElementList().iterator().next().getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-02");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.EMPTY_LINK_MSG, processRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, processRemark.getTarget());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    assertTrue(
        processRemark.getElementList().iterator().next().getValue().contains("my-link.html"));
    assertEquals(
        AttributeStore.HREF_ATTR,
        processRemark.getElementList().iterator().next().getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-03------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-03");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.EMPTY_LINK_MSG, processRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, processRemark.getTarget());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    assertTrue(
        processRemark.getElementList().iterator().next().getValue().contains("my-link.html"));
    assertEquals(
        AttributeStore.HREF_ATTR,
        processRemark.getElementList().iterator().next().getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-04------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-04");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.EMPTY_LINK_MSG, processRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, processRemark.getTarget());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    assertTrue(
        processRemark.getElementList().iterator().next().getValue().contains("my-link.html"));
    assertEquals(
        AttributeStore.HREF_ATTR,
        processRemark.getElementList().iterator().next().getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-05------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-05");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.EMPTY_LINK_MSG, processRemark.getMessageCode());
    assertEquals(HtmlElementStore.A_ELEMENT, processRemark.getTarget());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    assertTrue(
        processRemark.getElementList().iterator().next().getValue().contains("my-link.html"));
    assertEquals(
        AttributeStore.HREF_ATTR,
        processRemark.getElementList().iterator().next().getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-01----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.06.06.01-4NA-01");
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check number of remarks and their value
    assertNull(processResult.getRemarkSet());
  }
Exemple #10
0
  @Override
  protected void setProcess() {
    ProcessResult processResult = processPageTest("AW22.Test.06.01.03-2Failed-01");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-02");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-03");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-04");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-05");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-06");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-07");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-2Failed-08");
    assertEquals(TestSolution.FAILED, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.FAILED,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-01");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-02");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(2, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[1]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-03");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(1, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.UNEXPLICIT_LINK_WITH_CONTEXT_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-05");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(1, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.CHECK_LINK_WITH_CONTEXT_PERTINENCE_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-06");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(1, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.CHECK_LINK_WITH_CONTEXT_PERTINENCE_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-3NMI-07");
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    assertEquals(1, processResult.getRemarkSet().size());
    assertEquals(
        RemarkMessageStore.CHECK_LINK_WITH_CONTEXT_PERTINENCE_MSG,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getMessageCode());
    assertEquals(
        TestSolution.NEED_MORE_INFO,
        ((ProcessRemark) processResult.getRemarkSet().toArray()[0]).getIssue());

    processResult = processPageTest("AW22.Test.06.01.03-4NA-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.03-4NA-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.03-4NA-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.03-4NA-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    // 06.01.01 testcases : All is Not Applicable
    processResult = processPageTest("AW22.Test.06.01.01-2Failed-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-07");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-2Failed-08");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.01-3NMI-07");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    // 06.01.02 testcases : All is Not Applicable
    processResult = processPageTest("AW22.Test.06.01.02-2Failed-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-07");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-08");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-09");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-10");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-11");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-2Failed-12");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-3NMI-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-3NMI-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-3NMI-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-3NMI-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.02-3NMI-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    // 06.01.04 testcases : All is Not Applicable
    processResult = processPageTest("AW22.Test.06.01.04-2Failed-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-06");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-07");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-08");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-09");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-10");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-11");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-2Failed-12");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-3NMI-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-3NMI-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-3NMI-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-3NMI-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.01.04-3NMI-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    // 06.06.01 testcases : All is Not Applicable
    processResult = processPageTest("AW22.Test.06.06.01-2Failed-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.06.01-2Failed-02");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.06.01-2Failed-03");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.06.01-2Failed-04");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.06.01-2Failed-05");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());

    processResult = processPageTest("AW22.Test.06.06.01-4NA-01");
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    assertNull(processResult.getRemarkSet());
  }
Exemple #11
0
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------3NMI-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("Rgaa22.Test.3.12-3NMI-01");
    // check number of elements in the page
    assertEquals(3, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(3, processResult.getRemarkSet().size());
    Iterator<ProcessRemark> pIter = processResult.getRemarkSet().iterator();

    SourceCodeRemark processRemark = (SourceCodeRemark) pIter.next();
    assertEquals(RemarkMessageStore.CHECK_LABEL_PERTINENCE_MSG, processRemark.getMessageCode());
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(HtmlElementStore.LABEL_ELEMENT, processRemark.getTarget());
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(2, processRemark.getElementList().size());
    Iterator<EvidenceElement> iter = processRemark.getElementList().iterator();
    EvidenceElement ee = iter.next();
    assertEquals("", ee.getValue());
    assertEquals(HtmlElementStore.TEXT_ELEMENT2, ee.getEvidence().getCode());
    ee = iter.next();
    assertEquals("attribute-absent", ee.getValue());
    assertEquals(TITLE_ATTR, ee.getEvidence().getCode());

    processRemark = (SourceCodeRemark) pIter.next();
    assertEquals(RemarkMessageStore.CHECK_LABEL_PERTINENCE_MSG, processRemark.getMessageCode());
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(HtmlElementStore.LABEL_ELEMENT, processRemark.getTarget());
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(2, processRemark.getElementList().size());
    iter = processRemark.getElementList().iterator();
    ee = iter.next();
    assertEquals("Input label", ee.getValue());
    assertEquals(HtmlElementStore.TEXT_ELEMENT2, ee.getEvidence().getCode());
    ee = iter.next();
    assertEquals("", ee.getValue());
    assertEquals(TITLE_ATTR, ee.getEvidence().getCode());

    processRemark = (SourceCodeRemark) pIter.next();
    assertEquals(RemarkMessageStore.CHECK_LABEL_PERTINENCE_MSG, processRemark.getMessageCode());
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(HtmlElementStore.LABEL_ELEMENT, processRemark.getTarget());
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(2, processRemark.getElementList().size());
    iter = processRemark.getElementList().iterator();
    ee = iter.next();
    assertEquals("", ee.getValue());
    assertEquals(HtmlElementStore.TEXT_ELEMENT2, ee.getEvidence().getCode());
    ee = iter.next();
    assertEquals("Input label", ee.getValue());
    assertEquals(TITLE_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-01----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.3.12-4NA-01");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-02----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("Rgaa22.Test.3.12-4NA-02");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
  }
Exemple #12
0
  @Override
  protected void setProcess() {
    // ----------------------------------------------------------------------
    // ------------------------------2Failed-01------------------------------
    // ----------------------------------------------------------------------
    ProcessResult processResult = processPageTest("AW22.Test.5.2.1-2Failed-01");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    SourceCodeRemark processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.NOT_PERTINENT_SUMMARY_MSG, processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    EvidenceElement ee = processRemark.getElementList().iterator().next();
    assertEquals("", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-02------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-2Failed-02");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.NOT_PERTINENT_SUMMARY_MSG, processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("#^;:/", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------2Failed-03------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-2Failed-03");
    // check number of elements in the page
    assertEquals(3, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.FAILED, processResult.getValue());
    // check number of remarks and their value
    assertEquals(3, processResult.getRemarkSet().size());
    Iterator<ProcessRemark> iter = processResult.getRemarkSet().iterator();

    processRemark = (SourceCodeRemark) iter.next();
    assertEquals(TestSolution.FAILED, processRemark.getIssue());
    assertEquals(RemarkMessageStore.NOT_PERTINENT_SUMMARY_MSG, processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    processRemark = (SourceCodeRemark) iter.next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        RemarkMessageStore.CHECK_NATURE_OF_TABLE_AND_SUMMARY_PERTINENCE_MSG,
        processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("Summary of table without marker", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    processRemark = (SourceCodeRemark) iter.next();
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        RemarkMessageStore.CHECK_NATURE_OF_TABLE_FOR_NOT_PERTINENT_SUMMARY_MSG,
        processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("$$##''''", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------3NMI-01--------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-3NMI-01");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        RemarkMessageStore.CHECK_NATURE_OF_TABLE_AND_SUMMARY_PERTINENCE_MSG,
        processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("Summary of not identified table", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------3NMI-02--------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-3NMI-02");
    // check number of elements in the page
    assertEquals(1, processResult.getElementCounter());
    // check test result
    assertEquals(TestSolution.NEED_MORE_INFO, processResult.getValue());
    // check number of remarks and their value
    assertEquals(1, processResult.getRemarkSet().size());
    processRemark =
        ((SourceCodeRemark) ((LinkedHashSet) processResult.getRemarkSet()).iterator().next());
    assertEquals(TestSolution.NEED_MORE_INFO, processRemark.getIssue());
    assertEquals(
        RemarkMessageStore.CHECK_SUMMARY_PERTINENCE_FOR_DATA_TABLE_MSG,
        processRemark.getMessageCode());
    assertTrue(processRemark.getTarget().equalsIgnoreCase(HtmlElementStore.TABLE_ELEMENT));
    assertNotNull(processRemark.getSnippet());
    // check number of evidence elements and their value
    assertEquals(1, processRemark.getElementList().size());
    ee = processRemark.getElementList().iterator().next();
    assertEquals("Summary of data table", ee.getValue());
    assertEquals(SUMMARY_ATTR, ee.getEvidence().getCode());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-01----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-4NA-01");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-02----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-4NA-02");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());

    // ----------------------------------------------------------------------
    // ------------------------------4NA-03----------------------------------
    // ----------------------------------------------------------------------
    processResult = processPageTest("AW22.Test.5.2.1-4NA-03");
    // check test result
    assertEquals(TestSolution.NOT_APPLICABLE, processResult.getValue());
    // check test has no remark
    assertNull(processResult.getRemarkSet());
    // check number of elements in the page
    assertEquals(0, processResult.getElementCounter());
  }