The Tor Browser: accessible/tests/mochitest/relations.js@7e26c7da4463 (annotated)

accessible/tests/mochitest/relations.js@7e26c7da4463 (annotated)

accessible/tests/mochitest/relations.js

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 ////////////////////////////////////////////////////////////////////////////////
 // Constants
 const RELATION_CONTROLLED_BY = nsIAccessibleRelation.RELATION_CONTROLLED_BY;
 const RELATION_CONTROLLER_FOR = nsIAccessibleRelation.RELATION_CONTROLLER_FOR;
 const RELATION_DEFAULT_BUTTON = nsIAccessibleRelation.RELATION_DEFAULT_BUTTON;
 const RELATION_DESCRIBED_BY = nsIAccessibleRelation.RELATION_DESCRIBED_BY;
 const RELATION_DESCRIPTION_FOR = nsIAccessibleRelation.RELATION_DESCRIPTION_FOR;
 const RELATION_EMBEDDED_BY = nsIAccessibleRelation.RELATION_EMBEDDED_BY;
 const RELATION_EMBEDS = nsIAccessibleRelation.RELATION_EMBEDS;
 const RELATION_FLOWS_FROM = nsIAccessibleRelation.RELATION_FLOWS_FROM;
 const RELATION_FLOWS_TO = nsIAccessibleRelation.RELATION_FLOWS_TO;
 const RELATION_LABEL_FOR = nsIAccessibleRelation.RELATION_LABEL_FOR;
 const RELATION_LABELLED_BY = nsIAccessibleRelation.RELATION_LABELLED_BY;
 const RELATION_MEMBER_OF = nsIAccessibleRelation.RELATION_MEMBER_OF;
 const RELATION_NODE_CHILD_OF = nsIAccessibleRelation.RELATION_NODE_CHILD_OF;
 const RELATION_NODE_PARENT_OF = nsIAccessibleRelation.RELATION_NODE_PARENT_OF;
 const RELATION_PARENT_WINDOW_OF = nsIAccessibleRelation.RELATION_PARENT_WINDOW_OF;
 const RELATION_POPUP_FOR = nsIAccessibleRelation.RELATION_POPUP_FOR;
 const RELATION_SUBWINDOW_OF = nsIAccessibleRelation.RELATION_SUBWINDOW_OF;
 const RELATION_CONTAINING_DOCUMENT = nsIAccessibleRelation.RELATION_CONTAINING_DOCUMENT;
 const RELATION_CONTAINING_TAB_PANE = nsIAccessibleRelation.RELATION_CONTAINING_TAB_PANE;
 const RELATION_CONTAINING_APPLICATION = nsIAccessibleRelation.RELATION_CONTAINING_APPLICATION;
 ////////////////////////////////////////////////////////////////////////////////
 // General
 /**
  * Test the accessible relation.
  *
  * @param aIdentifier          [in] identifier to get an accessible, may be ID
  *                             attribute or DOM element or accessible object
  * @param aRelType             [in] relation type (see constants above)
  * @param aRelatedIdentifiers  [in] identifier or array of identifiers of
  *                             expected related accessibles
  */
 function testRelation(aIdentifier, aRelType, aRelatedIdentifiers)
 {
   var relation = getRelationByType(aIdentifier, aRelType);
   var relDescr = getRelationErrorMsg(aIdentifier, aRelType);
   var relDescrStart = getRelationErrorMsg(aIdentifier, aRelType, true);
   if (!relation || !relation.targetsCount) {
     if (!aRelatedIdentifiers) {
       ok(true, "No" + relDescr);
       return;
     }
     var msg = relDescrStart + "has no expected targets: '" +
       prettyName(aRelatedIdentifiers) + "'";
     ok(false, msg);
     return;
   } else if (!aRelatedIdentifiers) {
     ok(false, "There are unexpected targets of " + relDescr);
     return;
   }
   var relatedIds = (aRelatedIdentifiers instanceof Array) ?
   aRelatedIdentifiers : [aRelatedIdentifiers];
   var targets = [];
    for (var idx = 0; idx < relatedIds.length; idx++)
      targets.push(getAccessible(relatedIds[idx]));
   if (targets.length != relatedIds.length)
     return;
   var actualTargets = relation.getTargets();
   // Check if all given related accessibles are targets of obtained relation.
   for (var idx = 0; idx < targets.length; idx++) {
     var isFound = false;
     var enumerate = actualTargets.enumerate();
     while (enumerate.hasMoreElements()) {
       var relatedAcc = enumerate.getNext().QueryInterface(nsIAccessible);
       if (targets[idx] == relatedAcc) {
         isFound = true;
         break;
       }
     }
     ok(isFound, prettyName(relatedIds[idx]) + " is not a target of" + relDescr);
   }
   // Check if all obtained targets are given related accessibles.
   var enumerate = actualTargets.enumerate();
   while (enumerate.hasMoreElements()) {
     var relatedAcc = enumerate.getNext().QueryInterface(nsIAccessible);
     for (var idx = 0; idx < targets.length && relatedAcc != targets[idx]; idx++);
     if (idx == targets.length)
       ok(false, "There is unexpected target" + prettyName(relatedAcc) + "of" + relDescr);
   }
 }
 /**
  * Test that the given accessible relations don't exist.
  *
  * @param aIdentifier           [in] identifier to get an accessible, may be ID
  *                              attribute or DOM element or accessible object
  * @param aRelType              [in] relation type (see constants above)
  * @param aUnrelatedIdentifiers [in] identifier or array of identifiers of
  *                              accessibles that shouldn't exist for this
  *                              relation.
  */
 function testAbsentRelation(aIdentifier, aRelType, aUnrelatedIdentifiers)
 {
   var relation = getRelationByType(aIdentifier, aRelType);
   var relDescr = getRelationErrorMsg(aIdentifier, aRelType);
   var relDescrStart = getRelationErrorMsg(aIdentifier, aRelType, true);
   if (!aUnrelatedIdentifiers) {
     ok(false, "No identifiers given for unrelated accessibles.");
     return;
   }
   if (!relation || !relation.targetsCount) {
     ok(true, "No relations exist.");
     return;
   }
   var relatedIds = (aUnrelatedIdentifiers instanceof Array) ?
     aUnrelatedIdentifiers : [aUnrelatedIdentifiers];
   var targets = [];
   for (var idx = 0; idx < relatedIds.length; idx++)
     targets.push(getAccessible(relatedIds[idx]));
   if (targets.length != relatedIds.length)
     return;
   var actualTargets = relation.getTargets();
   // Any found targets that match given accessibles should be called out.
   for (var idx = 0; idx < targets.length; idx++) {
     var notFound = true;
     var enumerate = actualTargets.enumerate();
     while (enumerate.hasMoreElements()) {
       var relatedAcc = enumerate.getNext().QueryInterface(nsIAccessible);
       if (targets[idx] == relatedAcc) {
         notFound = false;
         break;
       }
     }
     ok(notFound, prettyName(relatedIds[idx]) + " is a target of " + relDescr);
   }
 }
 /**
  * Return related accessible for the given relation type.
  *
  * @param aIdentifier  [in] identifier to get an accessible, may be ID attribute
  *                     or DOM element or accessible object
  * @param aRelType     [in] relation type (see constants above)
  */
 function getRelationByType(aIdentifier, aRelType)
 {
   var acc = getAccessible(aIdentifier);
   if (!acc)
     return;
   var relation = null;
   try {
     relation = acc.getRelationByType(aRelType);
   } catch (e) {
     ok(false, "Can't get" + getRelationErrorMsg(aIdentifier, aRelType));
   }
   return relation;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Private implementation details
 function getRelationErrorMsg(aIdentifier, aRelType, aIsStartSentence)
 {
   var relStr = relationTypeToString(aRelType);
   var msg = aIsStartSentence ? "Relation of '" : " relation of '";
   msg += relStr + "' type for '" + prettyName(aIdentifier) + "'";
   msg += aIsStartSentence ? " " : ".";
   return msg;
 }