Implement word wrapping and panning in multiline Braille.

chrome/browser/resources/chromeos/chromevox/braille/braille_display_manager_test.unitjs

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Include test fixture.
 GEN_INCLUDE(['../testing/chromevox_unittest_base.js',
              '../testing/fake_objects.js']);
 
 /**
  * Test fixture.
@@ skipping 14 matching lines @@
   ],
 
   /** @override */
   setUp: function() {
     /** @const */
     this.NAV_BRAILLE = new cvox.NavBraille({ text: 'Hello, world!' });
     this.EMPTY_NAV_BRAILLE = new cvox.NavBraille({ text: '' });
     this.translator = new FakeTranslator();
     this.translatorManager = new FakeTranslatorManager();
     /** @const */
-    this.DISPLAY_SIZE = 12;
+    this.DISPLAY_ROW_SIZE = 1;
+    this.DISPLAY_COLUMN_SIZE = 12;
   },
 
   addFakeApi: function() {
     chrome.brailleDisplayPrivate = {};
     chrome.brailleDisplayPrivate.getDisplayState = function(callback) {
       callback(this.displayState);
     }.bind(this);
     this.writtenCells = [];
     chrome.brailleDisplayPrivate.writeDots = function(cells) {
       this.writtenCells.push(cells);
     }.bind(this);
     chrome.brailleDisplayPrivate.onDisplayStateChanged = new FakeChromeEvent();
     chrome.brailleDisplayPrivate.onKeyEvent = new FakeChromeEvent();
   },
 
   displayAvailable: function() {
-    this.displayState = {available: true, textRowCount: 1, textColumnCount: this.DISPLAY_SIZE};
+    this.displayState = {available: true, textRowCount: this.DISPLAY_ROW_SIZE,
+        textColumnCount: this.DISPLAY_COLUMN_SIZE};
   },
 
   /**
    * Asserts display pan position and selection markers on the last written
    * display content and clears it.  There must be exactly one
    * set of cells written.
-   * @param {number} start expected pan position
-   * @param {number=} opt_selStart first cell (relative to buffer start that
+   * @param {number} start expected pan position in the braille display
+   * @param {number=} opt_selStart first cell (relative to buffer start) that
    *                               should have a selection
    * @param {number=} opt_selEnd last cell that should have a selection.
    */
   assertDisplayPositionAndClear: function(start, opt_selStart, opt_selEnd) {
     if (opt_selStart !== undefined && opt_selEnd === undefined) {
       opt_selEnd = opt_selStart + 1;
     }
     assertEquals(1, this.writtenCells.length);
     var a = new Uint8Array(this.writtenCells[0]);
     this.writtenCells.length = 0;
     var firstCell = a[0] & ~cvox.BrailleDisplayManager.CURSOR_DOTS_;
+    // We are asserting that start, which is an index, and firstCell,
+    // which is a value, are the same because the fakeTranslator generates
+    // the values of the braille cells based on indices.
+    console.log(a[2]);

[David Tseng, 2016/11/30 22:11:54]

nit: remove debug logging.

[ultimatedbz, 2016/12/01 05:12:15]

Done.

     assertEquals(start, firstCell,
-                 'Start mismatch: ' + start + ' vs. ' + firstCell);
+                 ' Start mismatch: ' + start + ' vs. ' + firstCell);
     if (opt_selStart !== undefined) {
       for (var i = opt_selStart; i < opt_selEnd; ++i) {
         assertEquals(cvox.BrailleDisplayManager.CURSOR_DOTS_,
                      a[i] & cvox.BrailleDisplayManager.CURSOR_DOTS_,
                      'Missing cursor marker at position ' + i);
       }
     }
   },
 
   /**
@@ skipping 17 matching lines @@
   }
 };
 
 /** @extends {cvox.ExpandingBrailleTranslator} */
 function FakeTranslator() {
 }
 
 FakeTranslator.prototype = {
   /**
    * Does a translation where every other character becomes two cells.
+   * The translated text does not correspond with the actual content of
+   * the original text, but instead uses the indices. Each even index of the
+   * original text is mapped to one translated cell, while each odd index is
+   * mapped to two translated cells.
    * @override
    */
   translate: function(spannable, expansionType, callback) {
     text = spannable.toString();
     var buf = new Uint8Array(text.length + text.length / 2);
     var textToBraille = [];
     var brailleToText = [];
     var idx = 0;
     for (var i = 0; i < text.length; ++i) {
       textToBraille.push(idx);
@@ skipping 119 matching lines @@
   this.displayAvailable();
 
   var manager = new cvox.BrailleDisplayManager(this.translatorManager);
   this.assertEmptyDisplayAndClear();
   this.translatorManager.setTranslator(this.translator);
   this.assertEmptyDisplayAndClear();
 
   // Cursor at beginning of line.
   manager.setContent(createNavBrailleWithCursor(0, 0));
   this.assertDisplayPositionAndClear(0, 0);
-  // Cursor at end of line.
+  // When cursor at end of line.
   manager.setContent(createNavBrailleWithCursor(text.length, text.length));
+  // The first braille cell should be the result of the equation below.
   this.assertDisplayPositionAndClear(
-      2 * this.DISPLAY_SIZE,
-      translatedSize % this.DISPLAY_SIZE);
+      Math.floor(translatedSize / this.DISPLAY_COLUMN_SIZE) *
+          this.DISPLAY_COLUMN_SIZE,
+      translatedSize % this.DISPLAY_COLUMN_SIZE);
   // Selection from the end of what fits on the first display to the end of the
   // line.
   manager.setContent(createNavBrailleWithCursor(7, text.length));
-  this.assertDisplayPositionAndClear(0, 10, this.DISPLAY_SIZE);
+  this.assertDisplayPositionAndClear(0, 10, this.DISPLAY_COLUMN_SIZE);
   // Selection on all of the line.
   manager.setContent(createNavBrailleWithCursor(0, text.length));
-  this.assertDisplayPositionAndClear(0, 0, this.DISPLAY_SIZE);
+  this.assertDisplayPositionAndClear(0, 0, this.DISPLAY_COLUMN_SIZE);
 });
 
 /**
  * Tests that the grouping algorithm works with one text character that maps
  * to one braille cell.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'BasicGroup', function() {
   var text = 'a';
   var translated = '1';
   var mapping = [0];
   var expected = [['a','1']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(
-                                                     translated, text, mapping);
+                                                translated, text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });
 
 /**
  * Tests that the grouping algorithm works with one text character that maps
  * to multiple braille cells.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'OneRtoManyB', function() {
   var text = 'A';
   var translated = '11';
   var mapping = [0,0];
   var expected = [['A', '11']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(
-                                                     translated, text, mapping);
+                                        translated, text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });
 
 /**
  * Tests that the grouping algorithm works with one braille cell that maps
  * to multiple text characters.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'OneBtoManyR', function() {
   var text = 'knowledge';
   var translated = '1';
   var mapping = [0];
   var expected = [['knowledge', '1']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(
-                                                     translated, text, mapping);
+                                             translated, text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });
 
 /**
  * Tests that the grouping algorithm works with one string that on both ends,
  * have text characters that map to multiple braille cells.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'OneRtoManyB_BothEnds', function() {
   var text = 'AbbC';
   var translated = 'X122X3';
   var mapping = [0,0,1,2,3,3];
   var expected = [['A', 'X1'], ['b', '2'],['b', '2'], ['C', 'X3']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(
-                                                     translated, text, mapping);
+                                             translated, text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });
 
 /**
  * Tests that the grouping algorithm works with one string that on both ends,
  * have braille cells that map to multiple text characters.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'OneBtoManyR_BothEnds', function() {
   var text = 'knowledgehappych';
   var translated = '1234456';
   var mapping = [0, 9, 10, 11, 12, 13, 14];
   var expected = [['knowledge', '1'], ['h', '2'], ['a', '3'], ['p', '4'],
       ['p', '4'], ['y', '5'], ['ch', '6']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(translated,
-                                                                 text, mapping);
+                                                         text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });
 
 /**
  * Tests that the grouping algorithm works with one  string that has both types
  * of mapping.
  */
 TEST_F('CvoxBrailleDisplayManagerUnitTest', 'RandB_Random', function() {
   var text = 'knowledgeIsPower';
   var translated = '1X23X45678';
   var mapping = [0, 9, 9, 10, 11, 11, 12, 13, 14, 15];
   var expected = [['knowledge', '1'], ['I', 'X2'], ['s', '3'], ['P', 'X4'],
                            ['o', '5'], ['w', '6'], ['e', '7'], ['r', '8']];
+  var offsets = {brailleOffset: 0, textOffset: 0};
 
   var groups = cvox.BrailleCaptionsBackground.groupBrailleAndText(
-                                                     translated, text, mapping);
+                                             translated, text, mapping, offsets);
   this.assertGroupsValid(groups, expected);
 });