tor-browser

table.js (21624B)

---

/**
* This file provides set of helper functions to test nsIAccessibleTable
* interface.
*
* Required:
*   common.js
*   role.js
*   states.js
*/
/* import-globals-from common.js */
/* import-globals-from role.js */
/* import-globals-from states.js */

/**
* Constants used to describe cells array.
*/
const kDataCell = 1; // Indicates the cell is origin data cell
const kRowHeaderCell = 2; // Indicates the cell is row header cell
const kColHeaderCell = 4; // Indicated the cell is column header cell
const kOrigin = kDataCell | kRowHeaderCell | kColHeaderCell;

const kRowSpanned = 8; // Indicates the cell is not origin and row spanned
const kColSpanned = 16; // Indicates the cell is not origin and column spanned
const kSpanned = kRowSpanned | kColSpanned;

/**
* Constants to define column header type.
*/
const kNoColumnHeader = 0;
const kListboxColumnHeader = 1;
const kTreeColumnHeader = 2;

/**
* Constants to define table type.
*/
const kTable = 0;
const kTreeTable = 1;
const kMathTable = 2;

/**
* Test table structure and related methods.
*
* @param  aIdentifier     [in] table accessible identifier
* @param  aCellsArray     [in] two dimensional array (row X columns) of
*                          cell types (see constants defined above).
* @param  aColHeaderType  [in] specifies wether column header cells are
*                          arranged into the list.
* @param  aCaption        [in] caption text if any
* @param  aSummary        [in] summary text if any
* @param  aTableType      [in] specifies the table type.
* @param  aRowRoles       [in] array of row roles.
*/
function testTableStruct(
 aIdentifier,
 aCellsArray,
 aColHeaderType,
 aCaption,
 aSummary,
 aTableType,
 aRowRoles
) {
 var tableNode = getNode(aIdentifier);
 var isGrid =
   tableNode.getAttribute("role") == "grid" ||
   tableNode.getAttribute("role") == "treegrid" ||
   tableNode.localName == "tree";

 var rowCount = aCellsArray.length;
 var colsCount = aCellsArray[0] ? aCellsArray[0].length : 0;

 // Test table accessible tree.
 var tableObj = {
   children: [],
 };
 switch (aTableType) {
   case kTable:
     tableObj.role = ROLE_TABLE;
     break;
   case kTreeTable:
     tableObj.role = ROLE_TREE_TABLE;
     break;
   case kMathTable:
     tableObj.role = ROLE_MATHML_TABLE;
     break;
 }

 // caption accessible handling
 if (aCaption) {
   var captionObj = {
     role: ROLE_CAPTION,
     children: [
       {
         role: ROLE_TEXT_LEAF,
         name: aCaption,
       },
     ],
   };

   tableObj.children.push(captionObj);
 }

 // special types of column headers handling
 if (aColHeaderType) {
   var headersObj = {
     role: ROLE_LIST,
     children: [],
   };

   for (let idx = 0; idx < colsCount; idx++) {
     var headerCellObj = {
       role: ROLE_COLUMNHEADER,
     };
     headersObj.children.push(headerCellObj);
   }

   if (aColHeaderType == kTreeColumnHeader) {
     headersObj.children.push({
       role: ROLE_PUSHBUTTON,
     });
     headersObj.children.push({
       role: ROLE_MENUPOPUP,
     });
   }

   tableObj.children.push(headersObj);
 }

 // rows and cells accessibles
 for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   let rowObj = {
     role: aRowRoles ? aRowRoles[rowIdx] : ROLE_ROW,
     children: [],
   };

   for (let colIdx = 0; colIdx < colsCount; colIdx++) {
     let celltype = aCellsArray[rowIdx][colIdx];

     var role = ROLE_NOTHING;
     switch (celltype) {
       case kDataCell:
         role =
           aTableType == kMathTable
             ? ROLE_MATHML_CELL
             : isGrid
               ? ROLE_GRID_CELL
               : ROLE_CELL;
         break;
       case kRowHeaderCell:
         role = ROLE_ROWHEADER;
         break;
       case kColHeaderCell:
         role = ROLE_COLUMNHEADER;
         break;
     }

     if (role != ROLE_NOTHING) {
       var cellObj = { role };
       rowObj.children.push(cellObj);
     }
   }

   tableObj.children.push(rowObj);
 }

 testAccessibleTree(aIdentifier, tableObj);

 // Test table table interface.
 var table = getAccessible(aIdentifier, [nsIAccessibleTable]);

 // summary
 if (aSummary) {
   is(
     table.summary,
     aSummary,
     "Wrong summary of the table " + prettyName(aIdentifier)
   );
 }

 // rowCount and columnCount
 is(
   table.rowCount,
   rowCount,
   "Wrong rows count of " + prettyName(aIdentifier)
 );
 is(
   table.columnCount,
   colsCount,
   "Wrong columns count of " + prettyName(aIdentifier)
 );

 // rows and columns extents
 for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   for (let colIdx = 0; colIdx < colsCount; colIdx++) {
     let celltype = aCellsArray[rowIdx][colIdx];
     if (celltype & kOrigin) {
       // table getRowExtentAt
       var rowExtent = table.getRowExtentAt(rowIdx, colIdx);
       let idx;
       /* eslint-disable no-empty */
       for (
         idx = rowIdx + 1;
         idx < rowCount && aCellsArray[idx][colIdx] & kRowSpanned;
         idx++
       ) {}
       /* eslint-enable no-empty */

       var expectedRowExtent = idx - rowIdx;
       is(
         rowExtent,
         expectedRowExtent,
         "getRowExtentAt: Wrong number of spanned rows at (" +
           rowIdx +
           ", " +
           colIdx +
           ") for " +
           prettyName(aIdentifier)
       );

       // table getColumnExtentAt
       var colExtent = table.getColumnExtentAt(rowIdx, colIdx);
       /* eslint-disable no-empty */
       for (
         idx = colIdx + 1;
         idx < colsCount && aCellsArray[rowIdx][idx] & kColSpanned;
         idx++
       ) {}
       /* eslint-enable no-empty */

       var expectedColExtent = idx - colIdx;
       is(
         colExtent,
         expectedColExtent,
         "getColumnExtentAt: Wrong number of spanned columns at (" +
           rowIdx +
           ", " +
           colIdx +
           ") for " +
           prettyName(aIdentifier)
       );

       // cell rowExtent and columnExtent
       var cell = getAccessible(table.getCellAt(rowIdx, colIdx), [
         nsIAccessibleTableCell,
       ]);

       is(
         cell.rowExtent,
         expectedRowExtent,
         "rowExtent: Wrong number of spanned rows at (" +
           rowIdx +
           ", " +
           colIdx +
           ") for " +
           prettyName(aIdentifier)
       );

       is(
         cell.columnExtent,
         expectedColExtent,
         "columnExtent: Wrong number of spanned column at (" +
           rowIdx +
           ", " +
           colIdx +
           ") for " +
           prettyName(aIdentifier)
       );
     }
   }
 }
}

/**
* Test table indexes.
*
* @param  aIdentifier  [in] table accessible identifier
* @param  aIdxes       [in] two dimensional array of cell indexes
*/
function testTableIndexes(aIdentifier, aIdxes) {
 var tableAcc = getAccessible(aIdentifier, [nsIAccessibleTable]);
 if (!tableAcc) {
   return;
 }

 var obtainedRowIdx, obtainedColIdx, obtainedIdx;
 var cellAcc;

 var id = prettyName(aIdentifier);

 var rowCount = aIdxes.length;
 for (var rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   var colCount = aIdxes[rowIdx].length;
   for (var colIdx = 0; colIdx < colCount; colIdx++) {
     var idx = aIdxes[rowIdx][colIdx];

     // getCellAt
     try {
       cellAcc = null;
       cellAcc = tableAcc.getCellAt(rowIdx, colIdx);
     } catch (e) {}

     ok(
       (idx != -1 && cellAcc) || (idx == -1 && !cellAcc),
       id +
         ": Can't get cell accessible at row = " +
         rowIdx +
         ", column = " +
         colIdx
     );

     if (idx != -1) {
       // getRowIndexAt
       var origRowIdx = rowIdx;
       while (
         origRowIdx > 0 &&
         aIdxes[rowIdx][colIdx] == aIdxes[origRowIdx - 1][colIdx]
       ) {
         origRowIdx--;
       }

       try {
         obtainedRowIdx = tableAcc.getRowIndexAt(idx);
       } catch (e) {
         ok(
           false,
           id + ": can't get row index for cell index " + idx + "," + e
         );
       }

       is(
         obtainedRowIdx,
         origRowIdx,
         id + ": row for index " + idx + " is not correct (getRowIndexAt)"
       );

       // getColumnIndexAt
       var origColIdx = colIdx;
       while (
         origColIdx > 0 &&
         aIdxes[rowIdx][colIdx] == aIdxes[rowIdx][origColIdx - 1]
       ) {
         origColIdx--;
       }

       try {
         obtainedColIdx = tableAcc.getColumnIndexAt(idx);
       } catch (e) {
         ok(
           false,
           id + ": can't get column index for cell index " + idx + "," + e
         );
       }

       is(
         obtainedColIdx,
         origColIdx,
         id +
           ": column  for index " +
           idx +
           " is not correct (getColumnIndexAt)"
       );

       // getRowAndColumnIndicesAt
       var obtainedRowIdxObj = {},
         obtainedColIdxObj = {};
       try {
         tableAcc.getRowAndColumnIndicesAt(
           idx,
           obtainedRowIdxObj,
           obtainedColIdxObj
         );
       } catch (e) {
         ok(
           false,
           id +
             ": can't get row and column indices for cell index " +
             idx +
             "," +
             e
         );
       }

       is(
         obtainedRowIdxObj.value,
         origRowIdx,
         id +
           ": row for index " +
           idx +
           " is not correct (getRowAndColumnIndicesAt)"
       );
       is(
         obtainedColIdxObj.value,
         origColIdx,
         id +
           ": column  for index " +
           idx +
           " is not correct (getRowAndColumnIndicesAt)"
       );

       if (cellAcc) {
         var cellId = prettyName(cellAcc);
         cellAcc = getAccessible(cellAcc, [nsIAccessibleTableCell]);

         // cell: 'table-cell-index' attribute
         var attrs = cellAcc.attributes;
         var strIdx = "";
         try {
           strIdx = attrs.getStringProperty("table-cell-index");
         } catch (e) {
           ok(
             false,
             cellId +
               ": no cell index from object attributes on the cell accessible at index " +
               idx +
               "."
           );
         }

         if (strIdx) {
           is(
             parseInt(strIdx),
             idx,
             cellId +
               ": cell index from object attributes of cell accessible isn't corrent."
           );
         }

         // cell: table
         try {
           is(
             cellAcc.table,
             tableAcc,
             cellId + ": wrong table accessible for the cell."
           );
         } catch (e) {
           ok(false, cellId + ": can't get table accessible from the cell.");
         }

         // cell: getRowIndex
         try {
           obtainedRowIdx = cellAcc.rowIndex;
         } catch (e) {
           ok(
             false,
             cellId +
               ": can't get row index of the cell at index " +
               idx +
               "," +
               e
           );
         }

         is(
           obtainedRowIdx,
           origRowIdx,
           cellId + ": row for the cell at index " + idx + " is not correct"
         );

         // cell: getColumnIndex
         try {
           obtainedColIdx = cellAcc.columnIndex;
         } catch (e) {
           ok(
             false,
             cellId +
               ": can't get column index of the cell at index " +
               idx +
               "," +
               e
           );
         }

         is(
           obtainedColIdx,
           origColIdx,
           id + ": column for the cell at index " + idx + " is not correct"
         );
       }
     }

     // getCellIndexAt
     try {
       obtainedIdx = tableAcc.getCellIndexAt(rowIdx, colIdx);
     } catch (e) {
       obtainedIdx = -1;
     }

     is(
       obtainedIdx,
       idx,
       id +
         ": row " +
         rowIdx +
         " /column " +
         colIdx +
         " and index " +
         obtainedIdx +
         " aren't inconsistent."
     );
   }
 }
}

/**
* Test table getters selection methods.
*
* @param  aIdentifier  [in] table accessible identifier
* @param  aCellsArray  [in] two dimensional array (row X columns) of cells
*                       states (either boolean (selected/unselected) if cell is
*                       origin, otherwise kRowSpanned or kColSpanned constant).
* @param  aMsg         [in] text appended before every message
*/
function testTableSelection(aIdentifier, aCellsArray, aMsg) {
 var msg = aMsg ? aMsg : "";
 var acc = getAccessible(aIdentifier, [nsIAccessibleTable]);
 if (!acc) {
   return;
 }

 var rowCount = aCellsArray.length;
 var colsCount = aCellsArray[0].length;

 // Columns selection tests.
 var selCols = [];

 // isColumnSelected test
 for (let colIdx = 0; colIdx < colsCount; colIdx++) {
   var isColSelected = true;
   for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
     if (
       !aCellsArray[rowIdx][colIdx] ||
       aCellsArray[rowIdx][colIdx] == undefined
     ) {
       isColSelected = false;
       break;
     }
   }

   is(
     acc.isColumnSelected(colIdx),
     isColSelected,
     msg +
       "Wrong selection state of " +
       colIdx +
       " column for " +
       prettyName(aIdentifier)
   );

   if (isColSelected) {
     selCols.push(colIdx);
   }
 }

 // selectedColsCount test
 is(
   acc.selectedColumnCount,
   selCols.length,
   msg + "Wrong count of selected columns for " + prettyName(aIdentifier)
 );

 // getSelectedColumns test
 var actualSelCols = acc.getSelectedColumnIndices();

 var actualSelColsCount = actualSelCols.length;
 is(
   actualSelColsCount,
   selCols.length,
   msg +
     "Wrong count of selected columns for " +
     prettyName(aIdentifier) +
     "from getSelectedColumns."
 );

 for (let i = 0; i < actualSelColsCount; i++) {
   is(
     actualSelCols[i],
     selCols[i],
     msg + "Column at index " + selCols[i] + " should be selected."
   );
 }

 // Rows selection tests.
 var selRows = [];

 // isRowSelected test
 for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   var isRowSelected = true;
   for (let colIdx = 0; colIdx < colsCount; colIdx++) {
     if (
       !aCellsArray[rowIdx][colIdx] ||
       aCellsArray[rowIdx][colIdx] == undefined
     ) {
       isRowSelected = false;
       break;
     }
   }

   is(
     acc.isRowSelected(rowIdx),
     isRowSelected,
     msg +
       "Wrong selection state of " +
       rowIdx +
       " row for " +
       prettyName(aIdentifier)
   );

   if (isRowSelected) {
     selRows.push(rowIdx);
   }
 }

 // selectedRowCount test
 is(
   acc.selectedRowCount,
   selRows.length,
   msg + "Wrong count of selected rows for " + prettyName(aIdentifier)
 );

 // getSelectedRows test
 var actualSelRows = acc.getSelectedRowIndices();

 var actualSelrowCount = actualSelRows.length;
 is(
   actualSelrowCount,
   selRows.length,
   msg +
     "Wrong count of selected rows for " +
     prettyName(aIdentifier) +
     "from getSelectedRows."
 );

 for (let i = 0; i < actualSelrowCount; i++) {
   is(
     actualSelRows[i],
     selRows[i],
     msg + "Row at index " + selRows[i] + " should be selected."
   );
 }

 // Cells selection tests.
 var selCells = [];

 // isCellSelected test
 for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   for (let colIdx = 0; colIdx < colsCount; colIdx++) {
     if (aCellsArray[rowIdx][colIdx] & kSpanned) {
       continue;
     }

     var isSelected = !!aCellsArray[rowIdx][colIdx];
     is(
       acc.isCellSelected(rowIdx, colIdx),
       isSelected,
       msg +
         "Wrong selection state of cell at " +
         rowIdx +
         " row and " +
         colIdx +
         " column for " +
         prettyName(aIdentifier)
     );

     if (aCellsArray[rowIdx][colIdx]) {
       selCells.push(acc.getCellIndexAt(rowIdx, colIdx));
     }
   }
 }

 // selectedCellCount tests
 is(
   acc.selectedCellCount,
   selCells.length,
   msg + "Wrong count of selected cells for " + prettyName(aIdentifier)
 );

 // getSelectedCellIndices test
 var actualSelCells = acc.getSelectedCellIndices();

 var actualSelCellsCount = actualSelCells.length;
 is(
   actualSelCellsCount,
   selCells.length,
   msg +
     "Wrong count of selected cells for " +
     prettyName(aIdentifier) +
     "from getSelectedCells."
 );

 for (let i = 0; i < actualSelCellsCount; i++) {
   is(
     actualSelCells[i],
     selCells[i],
     msg +
       "getSelectedCellIndices: Cell at index " +
       selCells[i] +
       " should be selected."
   );
 }

 // selectedCells and isSelected tests
 var actualSelCellsArray = acc.selectedCells;
 for (let i = 0; i < actualSelCellsCount; i++) {
   var actualSelCellAccessible = actualSelCellsArray.queryElementAt(
     i,
     nsIAccessibleTableCell
   );

   let colIdx = acc.getColumnIndexAt(selCells[i]);
   let rowIdx = acc.getRowIndexAt(selCells[i]);
   var expectedSelCellAccessible = acc.getCellAt(rowIdx, colIdx);

   is(
     actualSelCellAccessible,
     expectedSelCellAccessible,
     msg +
       "getSelectedCells: Cell at index " +
       selCells[i] +
       " should be selected."
   );

   ok(
     actualSelCellAccessible.isSelected(),
     "isSelected: Cell at index " + selCells[i] + " should be selected."
   );
 }

 // selected states tests
 for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
   for (let colIdx = 0; colIdx < colsCount; colIdx++) {
     if (aCellsArray[rowIdx][colIdx] & kSpanned) {
       continue;
     }

     var cell = acc.getCellAt(rowIdx, colIdx);
     var isSel = aCellsArray[rowIdx][colIdx];
     if (isSel == undefined) {
       testStates(cell, 0, 0, STATE_SELECTABLE | STATE_SELECTED);
     } else if (isSel) {
       testStates(cell, STATE_SELECTED);
     } else {
       testStates(cell, STATE_SELECTABLE, 0, STATE_SELECTED);
     }
   }
 }
}

/**
* Test columnHeaderCells and rowHeaderCells of accessible table.
*/
function testHeaderCells(aHeaderInfoMap) {
 for (var testIdx = 0; testIdx < aHeaderInfoMap.length; testIdx++) {
   var dataCellIdentifier = aHeaderInfoMap[testIdx].cell;
   var dataCell = getAccessible(dataCellIdentifier, [nsIAccessibleTableCell]);

   // row header cells
   var rowHeaderCells = aHeaderInfoMap[testIdx].rowHeaderCells;
   var rowHeaderCellsCount = rowHeaderCells.length;
   var actualRowHeaderCells = dataCell.rowHeaderCells;
   var actualRowHeaderCellsCount = actualRowHeaderCells.length;

   is(
     actualRowHeaderCellsCount,
     rowHeaderCellsCount,
     "Wrong number of row header cells for the cell " +
       prettyName(dataCellIdentifier)
   );

   if (actualRowHeaderCellsCount == rowHeaderCellsCount) {
     for (let idx = 0; idx < rowHeaderCellsCount; idx++) {
       var rowHeaderCell = getAccessible(rowHeaderCells[idx]);
       var actualRowHeaderCell = actualRowHeaderCells.queryElementAt(
         idx,
         nsIAccessible
       );
       isObject(
         actualRowHeaderCell,
         rowHeaderCell,
         "Wrong row header cell at index " +
           idx +
           " for the cell " +
           dataCellIdentifier
       );
     }
   }

   // column header cells
   var colHeaderCells = aHeaderInfoMap[testIdx].columnHeaderCells;
   var colHeaderCellsCount = colHeaderCells.length;
   var actualColHeaderCells = dataCell.columnHeaderCells;
   var actualColHeaderCellsCount = actualColHeaderCells.length;

   is(
     actualColHeaderCellsCount,
     colHeaderCellsCount,
     "Wrong number of column header cells for the cell " +
       prettyName(dataCellIdentifier)
   );

   if (actualColHeaderCellsCount == colHeaderCellsCount) {
     for (let idx = 0; idx < colHeaderCellsCount; idx++) {
       var colHeaderCell = getAccessible(colHeaderCells[idx]);
       var actualColHeaderCell = actualColHeaderCells.queryElementAt(
         idx,
         nsIAccessible
       );
       isObject(
         actualColHeaderCell,
         colHeaderCell,
         "Wrong column header cell at index " +
           idx +
           " for the cell " +
           dataCellIdentifier
       );
     }
   }
 }
}

// //////////////////////////////////////////////////////////////////////////////
// private implementation

/**
* Return row and column of orig cell for the given spanned cell.
*/
function getOrigRowAndColumn(aCellsArray, aRowIdx, aColIdx) {
 var cellState = aCellsArray[aRowIdx][aColIdx];

 var origRowIdx = aRowIdx,
   origColIdx = aColIdx;
 if (cellState & kRowSpanned) {
   for (var prevRowIdx = aRowIdx - 1; prevRowIdx >= 0; prevRowIdx--) {
     let prevCellState = aCellsArray[prevRowIdx][aColIdx];
     if (!(prevCellState & kRowSpanned)) {
       origRowIdx = prevRowIdx;
       break;
     }
   }
 }

 if (cellState & kColSpanned) {
   for (var prevColIdx = aColIdx - 1; prevColIdx >= 0; prevColIdx--) {
     let prevCellState = aCellsArray[aRowIdx][prevColIdx];
     if (!(prevCellState & kColSpanned)) {
       origColIdx = prevColIdx;
       break;
     }
   }
 }

 return [origRowIdx, origColIdx];
}