Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/wincloud_gateway/node_modules/react-virtualized/dist/commonjs/MultiGrid/   drwxr-xr-x
Free 13.2 GB of 57.97 GB (22.78%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     MultiGrid.jest.js (25.05 KB)      -rw-r--r--

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var React = _interopRequireWildcard(require("react"));

var _reactDom = require("react-dom");

var _TestUtils = require("../TestUtils");

var _MultiGrid = _interopRequireDefault(require("./MultiGrid"));

var _CellMeasurer = require("../CellMeasurer");

// These tests only focus on what MultiGrid does specifically.
// The inner Grid component is tested in depth elsewhere.
describe('MultiGrid', function () {
  function defaultCellRenderer(_ref) {
    var columnIndex = _ref.columnIndex,
        key = _ref.key,
        rowIndex = _ref.rowIndex,
        style = _ref.style;
    return React.createElement("div", {
      className: "gridItem",
      key: key,
      style: style
    }, "row:".concat(rowIndex, ", column:").concat(columnIndex));
  }

  function getMarkup() {
    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return React.createElement(_MultiGrid["default"], (0, _extends2["default"])({
      cellRenderer: defaultCellRenderer,
      columnCount: 50,
      columnWidth: 50,
      fixedColumnCount: 2,
      fixedRowCount: 1,
      height: 300,
      overscanColumnCount: 0,
      overscanRowCount: 0,
      autoHeight: false,
      rowHeight: 20,
      rowCount: 100,
      width: 400
    }, props));
  }

  describe('fixed columns and rows', function () {
    it('should render 4 Grids when configured for fixed columns and rows', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 1,
        fixedRowCount: 1
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(4);

      var _grids = (0, _slicedToArray2["default"])(grids, 4),
          topLeft = _grids[0],
          topRight = _grids[1],
          bottomLeft = _grids[2],
          bottomRight = _grids[3];

      expect(topLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topLeft.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
    it('should render 2 Grids when configured for fixed columns only', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 1,
        fixedRowCount: 0
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(2);

      var _grids2 = (0, _slicedToArray2["default"])(grids, 2),
          bottomLeft = _grids2[0],
          bottomRight = _grids2[1];

      expect(bottomLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
    it('should render 2 Grids when configured for fixed rows only', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 0,
        fixedRowCount: 1
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(2);

      var _grids3 = (0, _slicedToArray2["default"])(grids, 2),
          topRight = _grids3[0],
          bottomRight = _grids3[1];

      expect(topRight.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
    it('should render 1 Grid when configured for neither fixed columns and rows', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 0,
        fixedRowCount: 0
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(1);

      var _grids4 = (0, _slicedToArray2["default"])(grids, 1),
          bottomRight = _grids4[0];

      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
    it('should adjust the number of Grids when fixed column or row counts change', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 2,
        fixedRowCount: 1
      })));
      expect(rendered.querySelectorAll('.ReactVirtualized__Grid').length).toEqual(4);
      rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 0,
        fixedRowCount: 0
      })));
      expect(rendered.querySelectorAll('.ReactVirtualized__Grid').length).toEqual(1);
      rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 0,
        fixedRowCount: 2
      })));
      expect(rendered.querySelectorAll('.ReactVirtualized__Grid').length).toEqual(2);
    });
    it('should allow scrolling of fixed Grids when configured for fixed columns and rows with scroll interaction', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        enableFixedColumnScroll: true,
        enableFixedRowScroll: true,
        fixedColumnCount: 1,
        fixedRowCount: 1
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(4);

      var _grids5 = (0, _slicedToArray2["default"])(grids, 4),
          topLeft = _grids5[0],
          topRight = _grids5[1],
          bottomLeft = _grids5[2],
          bottomRight = _grids5[3];

      expect(topLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topLeft.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(topRight.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-y')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
  });
  describe('hideTopRightGridScrollbar, hideBottomLeftGridScrollbar should hide the scrollbars', function () {
    function getScrollbarSize20() {
      return 20;
    }

    it('should add scroll wrappers to hide scroll bar when configured for fixed columns and rows with scroll interaction', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        enableFixedColumnScroll: true,
        enableFixedRowScroll: true,
        fixedColumnCount: 1,
        fixedRowCount: 1,
        hideTopRightGridScrollbar: true,
        hideBottomLeftGridScrollbar: true,
        getScrollbarSize: getScrollbarSize20
      })));
      var wrappers = rendered.querySelectorAll('.TopRightGrid_ScrollWrapper');
      expect(wrappers.length).toEqual(1);

      var _wrappers = wrappers,
          _wrappers2 = (0, _slicedToArray2["default"])(_wrappers, 1),
          topRightWrapper = _wrappers2[0];

      wrappers = rendered.querySelectorAll('.BottomLeftGrid_ScrollWrapper');
      expect(wrappers.length).toEqual(1);

      var _wrappers3 = wrappers,
          _wrappers4 = (0, _slicedToArray2["default"])(_wrappers3, 1),
          bottomLeftWrapper = _wrappers4[0];

      expect(topRightWrapper.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topRightWrapper.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(bottomLeftWrapper.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(bottomLeftWrapper.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(topRightWrapper.style.getPropertyValue('height')).toEqual('20px');
      expect(bottomLeftWrapper.style.getPropertyValue('height')).toEqual('280px');
      expect(topRightWrapper.style.getPropertyValue('width')).toEqual('350px');
      expect(bottomLeftWrapper.style.getPropertyValue('width')).toEqual('50px');
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(4);

      var _grids6 = (0, _slicedToArray2["default"])(grids, 4),
          topLeft = _grids6[0],
          topRight = _grids6[1],
          bottomLeft = _grids6[2],
          bottomRight = _grids6[3];

      expect(topLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(topLeft.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(topRight.style.getPropertyValue('overflow-y')).toEqual('hidden');
      expect(topRight.style.getPropertyValue('height')).toEqual('40px');
      expect(bottomLeft.style.getPropertyValue('overflow-x')).toEqual('hidden');
      expect(bottomLeft.style.getPropertyValue('overflow-y')).toEqual('auto');
      expect(bottomLeft.style.getPropertyValue('width')).toEqual('70px');
      expect(bottomRight.style.getPropertyValue('overflow-x')).toEqual('auto');
      expect(bottomRight.style.getPropertyValue('overflow-y')).toEqual('auto');
    });
  });
  describe('#recomputeGridSize', function () {
    it('should clear calculated cached styles in recomputeGridSize', function () {
      var fixedRowHeight = 75;
      var fixedColumnWidth = 100;

      function variableRowHeight(_ref2) {
        var index = _ref2.index;

        if (index === 0) {
          return fixedRowHeight;
        }

        return 20;
      }

      function variableColumnWidth(_ref3) {
        var index = _ref3.index;

        if (index === 0) {
          return fixedColumnWidth;
        }

        return 50;
      }

      var multiGrid;
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 1,
        fixedRowCount: 1,
        rowHeight: variableRowHeight,
        columnWidth: variableColumnWidth,
        ref: function ref(_ref4) {
          multiGrid = _ref4;
        }
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(grids.length).toEqual(4);

      var _grids7 = (0, _slicedToArray2["default"])(grids, 4),
          topLeft = _grids7[0],
          topRight = _grids7[1],
          bottomLeft = _grids7[2],
          bottomRight = _grids7[3];

      expect(topLeft.style.getPropertyValue('height')).toEqual('75px');
      expect(topRight.style.getPropertyValue('height')).toEqual('75px');
      expect(bottomLeft.style.getPropertyValue('height')).toEqual('225px');
      expect(bottomRight.style.getPropertyValue('height')).toEqual('225px');
      expect(topLeft.style.getPropertyValue('width')).toEqual('100px');
      expect(topRight.style.getPropertyValue('width')).toEqual('300px');
      expect(bottomLeft.style.getPropertyValue('width')).toEqual('100px');
      expect(bottomRight.style.getPropertyValue('width')).toEqual('300px');
      expect(multiGrid._topGridHeight).toEqual(75);
      expect(multiGrid._leftGridWidth).toEqual(100);
      fixedRowHeight = 125;
      fixedColumnWidth = 75;
      multiGrid.recomputeGridSize();
      expect(multiGrid._topGridHeight).toEqual(125);
      expect(multiGrid._leftGridWidth).toEqual(75);
      multiGrid.forceUpdate();
      var gridsAfter = rendered.querySelectorAll('.ReactVirtualized__Grid');
      expect(gridsAfter.length).toEqual(4);

      var _gridsAfter = (0, _slicedToArray2["default"])(gridsAfter, 4),
          topLeftAfter = _gridsAfter[0],
          topRightAfter = _gridsAfter[1],
          bottomLeftAfter = _gridsAfter[2],
          bottomRightAfter = _gridsAfter[3];

      expect(topLeftAfter.style.getPropertyValue('height')).toEqual('125px');
      expect(topRightAfter.style.getPropertyValue('height')).toEqual('125px');
      expect(bottomLeftAfter.style.getPropertyValue('height')).toEqual('175px');
      expect(bottomRightAfter.style.getPropertyValue('height')).toEqual('175px');
      expect(topLeftAfter.style.getPropertyValue('width')).toEqual('75px');
      expect(topRightAfter.style.getPropertyValue('width')).toEqual('325px');
      expect(bottomLeftAfter.style.getPropertyValue('width')).toEqual('75px');
      expect(bottomRightAfter.style.getPropertyValue('width')).toEqual('325px');
    });
  });
  describe('scrollToColumn and scrollToRow', function () {
    it('should adjust :scrollLeft for the main Grid when scrollToColumn is used', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        columnWidth: 50,
        fixedColumnCount: 2,
        scrollToAlignment: 'start',
        scrollToColumn: 19
      }))); // Bottom-right Grid is the last Grid

      var grid = rendered.querySelectorAll('.ReactVirtualized__Grid')[3]; // 20th column, less 2 for the fixed-column Grid, 50px column width

      expect(grid.scrollLeft).toEqual(850);
    });
    it('should adjust :scrollTop for the main Grid when scrollToRow is used', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedRowCount: 1,
        rowHeight: 50,
        scrollToAlignment: 'start',
        scrollToRow: 19
      }))); // Bottom-right Grid is the last Grid

      var grid = rendered.querySelectorAll('.ReactVirtualized__Grid')[3]; // 20th row, less 1 for the fixed-row Grid, 50px row width

      expect(grid.scrollTop).toEqual(900);
    });
  });
  describe('#forceUpdateGrids', function () {
    it('should call forceUpdate() on inner Grids', function () {
      var cellRenderer = jest.fn();
      cellRenderer.mockImplementation(function (_ref5) {
        var key = _ref5.key;
        return React.createElement("div", {
          key: key,
          style: {}
        });
      });
      var rendered = (0, _TestUtils.render)(getMarkup({
        cellRenderer: cellRenderer,
        columnCount: 2,
        fixedColumnCount: 1,
        fixedRowCount: 1,
        rowCount: 2
      }));
      expect(cellRenderer.mock.calls).toHaveLength(4);
      cellRenderer.mockReset();
      rendered.forceUpdateGrids();
      expect(cellRenderer.mock.calls).toHaveLength(4);
    });
  });
  describe('#invalidateCellSizeAfterRender', function () {
    it('should call invalidateCellSizeAfterRender() on inner Grids', function () {
      var cellRenderer = jest.fn();
      cellRenderer.mockImplementation(function (_ref6) {
        var key = _ref6.key;
        return React.createElement("div", {
          key: key,
          style: {}
        });
      });
      var rendered = (0, _TestUtils.render)(getMarkup({
        cellRenderer: cellRenderer,
        columnCount: 2,
        fixedColumnCount: 1,
        fixedRowCount: 1,
        rowCount: 2
      }));
      cellRenderer.mockReset();
      rendered.invalidateCellSizeAfterRender({
        columnIndex: 0,
        rowIndex: 0
      });
      rendered.forceUpdate();
      expect(cellRenderer.mock.calls).toHaveLength(4);
    });
    it('should specify itself as the :parent for CellMeasurer rendered cells', function () {
      // HACK For some reason, using Jest mock broke here
      var savedParent;

      function cellRenderer(_ref7) {
        var key = _ref7.key,
            parent = _ref7.parent;
        savedParent = parent;
        return React.createElement("div", {
          key: key,
          style: {}
        });
      }

      var rendered = (0, _TestUtils.render)(getMarkup({
        cellRenderer: cellRenderer,
        columnCount: 2,
        fixedColumnCount: 1,
        fixedRowCount: 1,
        rowCount: 2
      }));
      expect(savedParent).toBe(rendered);
    });
  });
  describe('styles', function () {
    it('should support custom style for the outer MultiGrid wrapper element', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        style: {
          backgroundColor: 'black'
        }
      })));
      expect(rendered.style.backgroundColor).toEqual('black');
    });
    it('should support custom styles for each Grid', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        fixedColumnCount: 2,
        fixedRowCount: 1,
        styleBottomLeftGrid: {
          backgroundColor: 'green'
        },
        styleBottomRightGrid: {
          backgroundColor: 'red'
        },
        styleTopLeftGrid: {
          backgroundColor: 'blue'
        },
        styleTopRightGrid: {
          backgroundColor: 'purple'
        }
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      var topLeftGrid = grids[0];
      var topRightGrid = grids[1];
      var bottomLeftGrid = grids[2];
      var bottomRightGrid = grids[3];
      expect(topLeftGrid.style.backgroundColor).toEqual('blue');
      expect(topRightGrid.style.backgroundColor).toEqual('purple');
      expect(bottomLeftGrid.style.backgroundColor).toEqual('green');
      expect(bottomRightGrid.style.backgroundColor).toEqual('red');
    });
  });
  describe('scrollTop and scrollLeft', function () {
    it('should adjust :scrollLeft for top-right and main grids when scrollLeft is used', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        columnWidth: 50,
        fixedColumnCount: 2,
        scrollLeft: 850
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      var topRightGrid = grids[1];
      var bottomRightGrid = grids[3];
      expect(topRightGrid.scrollLeft).toEqual(850);
      expect(bottomRightGrid.scrollLeft).toEqual(850);
    });
    it('should adjust :scrollTop for bottom-left and main grids when scrollTop is used', function () {
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        columnWidth: 50,
        fixedColumnCount: 2,
        scrollTop: 500
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      var bottomLeftGrid = grids[2];
      var bottomRightGrid = grids[3];
      expect(bottomLeftGrid.scrollTop).toEqual(500);
      expect(bottomRightGrid.scrollTop).toEqual(500);
    });
    it('should adjust :scrollTop and :scrollLeft when scrollTop and scrollLeft change', function () {
      (0, _TestUtils.render)(getMarkup());
      var rendered = (0, _reactDom.findDOMNode)((0, _TestUtils.render)(getMarkup({
        scrollTop: 750,
        scrollLeft: 900
      })));
      var grids = rendered.querySelectorAll('.ReactVirtualized__Grid');
      var topRightGrid = grids[1];
      var bottomLeftGrid = grids[2];
      var bottomRightGrid = grids[3];
      expect(topRightGrid.scrollLeft).toEqual(900);
      expect(bottomRightGrid.scrollLeft).toEqual(900);
      expect(bottomLeftGrid.scrollTop).toEqual(750);
      expect(bottomRightGrid.scrollTop).toEqual(750);
    });
    it('should not crash when decreasing :rowCount', function () {
      (0, _TestUtils.render)(getMarkup());
      var updated = (0, _TestUtils.render)(getMarkup({
        rowCount: 2
      }));
      expect(updated.props.rowCount).toEqual(2);
    });
    it('should not crash when decreasing :columnCount', function () {
      (0, _TestUtils.render)(getMarkup());
      var updated = (0, _TestUtils.render)(getMarkup({
        columnCount: 3
      }));
      expect(updated.props.columnCount).toEqual(3);
    });
  });
  describe('deferredMeasurementCache', function () {
    function getDeferredMeasurementCache() {
      var deferredMeasurementCache = new _CellMeasurer.CellMeasurerCache({
        fixedHeight: true,
        fixedWidth: true
      });
      deferredMeasurementCache._columnIndices = {};
      deferredMeasurementCache._rowIndices = {};

      deferredMeasurementCache.has = function (rowIndex, columnIndex) {
        deferredMeasurementCache._columnIndices[columnIndex] = columnIndex;
        deferredMeasurementCache._rowIndices[rowIndex] = rowIndex;
        return true;
      };

      return deferredMeasurementCache;
    }

    it('should wrap top-right and bottom-right deferredMeasurementCache if fixedColumnCount is > 0', function () {
      var deferredMeasurementCache = getDeferredMeasurementCache();
      (0, _TestUtils.render)(getMarkup({
        deferredMeasurementCache: deferredMeasurementCache,
        columnCount: 3,
        fixedColumnCount: 1,
        fixedRowCount: 0,
        rowCount: 1
      }));
      expect(Object.keys(deferredMeasurementCache._columnIndices)).toEqual(['0', '1', '2']);
    });
    it('should not wrap top-right and bottom-right deferredMeasurementCache if fixedColumnCount is 0', function () {
      var deferredMeasurementCache = getDeferredMeasurementCache();
      (0, _TestUtils.render)(getMarkup({
        deferredMeasurementCache: deferredMeasurementCache,
        columnCount: 2,
        fixedColumnCount: 0,
        fixedRowCount: 0,
        rowCount: 1
      }));
      expect(Object.keys(deferredMeasurementCache._columnIndices)).toEqual(['0', '1']);
    });
    it('should wrap bottom-left and bottom-right deferredMeasurementCache if fixedRowCount is > 0', function () {
      var deferredMeasurementCache = getDeferredMeasurementCache();
      (0, _TestUtils.render)(getMarkup({
        deferredMeasurementCache: deferredMeasurementCache,
        columnCount: 1,
        fixedColumnCount: 0,
        fixedRowCount: 1,
        rowCount: 3
      }));
      expect(Object.keys(deferredMeasurementCache._rowIndices)).toEqual(['0', '1', '2']);
    });
    it('should not wrap bottom-left and bottom-right deferredMeasurementCache if fixedRowCount is 0', function () {
      var deferredMeasurementCache = getDeferredMeasurementCache();
      (0, _TestUtils.render)(getMarkup({
        deferredMeasurementCache: deferredMeasurementCache,
        columnCount: 1,
        fixedColumnCount: 0,
        fixedRowCount: 0,
        rowCount: 2
      }));
      expect(Object.keys(deferredMeasurementCache._rowIndices)).toEqual(['0', '1']);
    });
  });
  describe('onScrollbarPresenceChange', function () {
    function getScrollbarSize20() {
      return 20;
    }

    it('should not trigger on-mount if scrollbars are hidden', function () {
      var onScrollbarPresenceChange = jest.fn();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 1,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 1
      }));
      expect(onScrollbarPresenceChange).not.toHaveBeenCalled();
    });
    it('should trigger on-mount if scrollbars are visible', function () {
      var onScrollbarPresenceChange = jest.fn();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 100,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 100
      }));
      expect(onScrollbarPresenceChange).toHaveBeenCalled();
      var args = onScrollbarPresenceChange.mock.calls[0][0];
      expect(args.horizontal).toBe(true);
      expect(args.size).toBe(getScrollbarSize20());
      expect(args.vertical).toBe(true);
    });
    it('should trigger on-update if scrollbar visibility has changed', function () {
      var onScrollbarPresenceChange = jest.fn();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 1,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 1
      }));
      expect(onScrollbarPresenceChange).not.toHaveBeenCalled();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 100,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 100
      }));
      expect(onScrollbarPresenceChange).toHaveBeenCalled();
      var args = onScrollbarPresenceChange.mock.calls[0][0];
      expect(args.horizontal).toBe(true);
      expect(args.size).toBe(getScrollbarSize20());
      expect(args.vertical).toBe(true);
    });
    it('should not trigger on-update if scrollbar visibility does not change', function () {
      var onScrollbarPresenceChange = jest.fn();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 1,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 1
      }));
      expect(onScrollbarPresenceChange).not.toHaveBeenCalled();
      (0, _TestUtils.render)(getMarkup({
        columnCount: 2,
        getScrollbarSize: getScrollbarSize20,
        onScrollbarPresenceChange: onScrollbarPresenceChange,
        rowCount: 2
      }));
      expect(onScrollbarPresenceChange).not.toHaveBeenCalled();
    });
  });
});