scratch-blocks 1.2.0-beta.1 → 2.0.0-beta.2

package/blockly-rc/tests/mocha/json_test.js

@@ -1,315 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../node_modules/chai/chai.js';
-import {
-  addMessageToCleanup,
-  sharedTestSetup,
-  sharedTestTeardown,
-} from './test_helpers/setup_teardown.js';
-import {assertNoWarnings, assertWarnings} from './test_helpers/warnings.js';
-
-suite('JSON Block Definitions', function () {
-  setup(function () {
-    sharedTestSetup.call(this);
-    this.workspace_ = new Blockly.Workspace();
-  });
-
-  teardown(function () {
-    sharedTestTeardown.call(this);
-  });
-
-  suite('defineBlocksWithJsonArray', function () {
-    test('Basic block', function () {
-      /**  Ensure a block can be instantiated from a JSON definition.  */
-      const BLOCK_TYPE = 'test_json_minimal';
-      let block;
-      assertNoWarnings(() => {
-        Blockly.defineBlocksWithJsonArray([
-          {
-            'type': BLOCK_TYPE,
-          },
-        ]);
-        block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      });
-
-      assert.isNotNull(block);
-      assert.equal(BLOCK_TYPE, block.type);
-    });
-
-    test('Null or undefined type id', function () {
-      const BLOCK_TYPE1 = 'test_json_before_bad_blocks';
-      const BLOCK_TYPE2 = 'test_json_after_bad_blocks';
-
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
-      const blockTypeCount = Object.keys(Blockly.Blocks).length;
-
-      assertWarnings(() => {
-        Blockly.defineBlocksWithJsonArray([
-          {'type': BLOCK_TYPE1},
-          {'type': undefined},
-          {'type': null},
-          {'type': BLOCK_TYPE2},
-        ]);
-      }, [/missing a type attribute/, /missing a type attribute/]);
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE1],
-        'Block before bad blocks should be defined.',
-      );
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE2],
-        'Block after bad blocks should be defined.',
-      );
-      assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-    });
-
-    test('Null item', function () {
-      const BLOCK_TYPE1 = 'test_block_before_null';
-      const BLOCK_TYPE2 = 'test_block_after_null';
-
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
-      const blockTypeCount = Object.keys(Blockly.Blocks).length;
-
-      assertWarnings(() => {
-        Blockly.defineBlocksWithJsonArray([
-          {
-            'type': BLOCK_TYPE1,
-            'message0': 'before',
-          },
-          null,
-          {
-            'type': BLOCK_TYPE2,
-            'message0': 'after',
-          },
-        ]);
-      }, /is null/);
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE1],
-        'Block before null in array should be defined.',
-      );
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE2],
-        'Block after null in array should be defined.',
-      );
-      assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-    });
-
-    test('Undefined item', function () {
-      const BLOCK_TYPE1 = 'test_block_before_undefined';
-      const BLOCK_TYPE2 = 'test_block_after_undefined';
-
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
-      const blockTypeCount = Object.keys(Blockly.Blocks).length;
-      assertWarnings(() => {
-        Blockly.defineBlocksWithJsonArray([
-          {
-            'type': BLOCK_TYPE1,
-            'message0': 'before',
-          },
-          undefined,
-          {
-            'type': BLOCK_TYPE2,
-            'message0': 'after',
-          },
-        ]);
-      }, /is undefined/);
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE1],
-        'Block before undefined in array should be defined.',
-      );
-      assert.isNotNull(
-        Blockly.Blocks[BLOCK_TYPE2],
-        'Block after undefined in array should be defined.',
-      );
-      assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-    });
-
-    test('message0 creates input', function () {
-      const BLOCK_TYPE = 'test_json_message0';
-      const MESSAGE0 = 'message0';
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': BLOCK_TYPE,
-          'message0': MESSAGE0,
-        },
-      ]);
-
-      const block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assert.equal(block.inputList.length, 1);
-      assert.equal(block.inputList[0].fieldRow.length, 1);
-      const textField = block.inputList[0].fieldRow[0];
-      assert.equal(Blockly.FieldLabel, textField.constructor);
-      assert.equal(MESSAGE0, textField.getText());
-    });
-
-    test('message1 and message0 creates two inputs', function () {
-      /**  Ensure message1 creates a new input.  */
-      const BLOCK_TYPE = 'test_json_message1';
-      const MESSAGE0 = 'message0';
-      const MESSAGE1 = 'message1';
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': BLOCK_TYPE,
-          'message0': MESSAGE0,
-          'message1': MESSAGE1,
-        },
-      ]);
-
-      const block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assert.equal(block.inputList.length, 2);
-
-      assert.equal(block.inputList[0].fieldRow.length, 1);
-      const firstTextField = block.inputList[0].fieldRow[0];
-      assert.equal(Blockly.FieldLabel, firstTextField.constructor);
-      assert.equal(MESSAGE0, firstTextField.getText());
-
-      assert.equal(block.inputList[1].fieldRow.length, 1);
-      const secondTextField = block.inputList[1].fieldRow[0];
-      assert.equal(Blockly.FieldLabel, secondTextField.constructor);
-      assert.equal(MESSAGE1, secondTextField.getText());
-    });
-
-    test('Message string is dereferenced', function () {
-      const BLOCK_TYPE = 'test_json_message0_i18n';
-      const MESSAGE0 = '%{BKY_MESSAGE}';
-      const MESSAGE = 'message';
-
-      addMessageToCleanup(this.sharedCleanup, 'MESSAGE');
-      Blockly.Msg['MESSAGE'] = MESSAGE;
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': BLOCK_TYPE,
-          'message0': MESSAGE0,
-        },
-      ]);
-
-      const block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assert.equal(block.inputList.length, 1);
-      assert.equal(block.inputList[0].fieldRow.length, 1);
-      const textField = block.inputList[0].fieldRow[0];
-      assert.equal(Blockly.FieldLabel, textField.constructor);
-      assert.equal(MESSAGE, textField.getText());
-    });
-
-    test('Dropdown', function () {
-      const BLOCK_TYPE = 'test_json_dropdown';
-      const FIELD_NAME = 'FIELD_NAME';
-      const LABEL0 = 'LABEL0';
-      const VALUE0 = 'VALUE0';
-      const LABEL1 = 'LABEL1';
-      const VALUE1 = 'VALUE1';
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': BLOCK_TYPE,
-          'message0': '%1',
-          'args0': [
-            {
-              'type': 'field_dropdown',
-              'name': FIELD_NAME,
-              'options': [
-                [LABEL0, VALUE0],
-                [LABEL1, VALUE1],
-              ],
-            },
-          ],
-        },
-      ]);
-
-      const block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assert.equal(block.inputList.length, 1);
-      assert.equal(block.inputList[0].fieldRow.length, 1);
-      const dropdown = block.inputList[0].fieldRow[0];
-      assert.equal(dropdown, block.getField(FIELD_NAME));
-      assert.equal(Blockly.FieldDropdown, dropdown.constructor);
-      assert.equal(VALUE0, dropdown.getValue());
-
-      const options = dropdown.getOptions();
-      assert.equal(LABEL0, options[0][0]);
-      assert.equal(VALUE0, options[0][1]);
-      assert.equal(LABEL1, options[1][0]);
-      assert.equal(VALUE1, options[1][1]);
-    });
-
-    test('Dropdown with images', function () {
-      const BLOCK_TYPE = 'test_json_dropdown';
-      const FIELD_NAME = 'FIELD_NAME';
-      const IMAGE1_ALT_TEXT = 'Localized message.';
-      addMessageToCleanup(this.sharedCleanup, 'ALT_TEXT');
-      Blockly.Msg['ALT_TEXT'] = IMAGE1_ALT_TEXT;
-      const IMAGE0 = {
-        'width': 12,
-        'height': 34,
-        'src': 'http://image0.src',
-        'alt': 'IMAGE0 alt text',
-      };
-      const VALUE0 = 'VALUE0';
-      const IMAGE1 = {
-        'width': 56,
-        'height': 78,
-        'src': 'http://image1.src',
-        'alt': '%{BKY_ALT_TEXT}',
-      };
-      const VALUE1 = 'VALUE1';
-      const IMAGE2 = {
-        'width': 90,
-        'height': 123,
-        'src': 'http://image2.src',
-      };
-      const VALUE2 = 'VALUE2';
-
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': BLOCK_TYPE,
-          'message0': '%1',
-          'args0': [
-            {
-              'type': 'field_dropdown',
-              'name': FIELD_NAME,
-              'options': [
-                [IMAGE0, VALUE0],
-                [IMAGE1, VALUE1],
-                [IMAGE2, VALUE2],
-              ],
-            },
-          ],
-        },
-      ]);
-
-      const block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assert.equal(block.inputList.length, 1);
-      assert.equal(block.inputList[0].fieldRow.length, 1);
-      const dropdown = block.inputList[0].fieldRow[0];
-      assert.equal(dropdown, block.getField(FIELD_NAME));
-      assert.equal(Blockly.FieldDropdown, dropdown.constructor);
-      assert.equal(VALUE0, dropdown.getValue());
-
-      function assertImageEquals(actualImage, expectedImage) {
-        assert.equal(actualImage.width, expectedImage.width);
-        assert.equal(actualImage.height, expectedImage.height);
-        assert.equal(actualImage.src, expectedImage.src);
-      }
-
-      const options = dropdown.getOptions();
-      const image0 = options[0][0];
-      assertImageEquals(IMAGE0, image0);
-      assert.equal(IMAGE0.alt, image0.alt);
-      assert.equal(options[0][1], VALUE0);
-
-      const image1 = options[1][0];
-      assertImageEquals(IMAGE1, image1);
-      assert.equal(image1.alt, IMAGE1_ALT_TEXT); // Via Msg reference
-      assert.equal(VALUE1, options[1][1]);
-
-      const image2 = options[2][0];
-      assertImageEquals(IMAGE1, image1);
-      assert.notExists(image2.alt); // No alt specified.
-      assert.equal(VALUE2, options[2][1]);
-    });
-  });
-});

package/blockly-rc/tests/mocha/keydown_test.js

@@ -1,364 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from '../../build/src/core/blockly.js';
-import {createKeyDownEvent} from './test_helpers/user_input.js';
-import {defineStackBlock} from './test_helpers/block_definitions.js';
-import {
-  sharedTestSetup,
-  sharedTestTeardown,
-} from './test_helpers/setup_teardown.js';
-
-suite('Key Down', function () {
-  setup(function () {
-    sharedTestSetup.call(this);
-    this.workspace = Blockly.inject('blocklyDiv', {});
-    this.injectionDiv = this.workspace.getInjectionDiv();
-  });
-  teardown(function () {
-    sharedTestTeardown.call(this);
-  });
-
-  /**
-   * Creates a block and sets it as Blockly.selected.
-   * @param {Blockly.Workspace} workspace The workspace to create a new block on.
-   * @return {Blockly.Block} The block being selected.
-   */
-  function setSelectedBlock(workspace) {
-    defineStackBlock();
-    const block = workspace.newBlock('stack_block');
-    Blockly.common.setSelected(block);
-    return block;
-  }
-
-  /**
-   * Creates a test for not running keyDown events when the workspace is in read only mode.
-   * @param {Object} keyEvent Mocked key down event. Use createKeyDownEvent.
-   * @param {string=} opt_name An optional name for the test case.
-   */
-  function runReadOnlyTest(keyEvent, opt_name) {
-    const name = opt_name ? opt_name : 'Not called when readOnly is true';
-    test(name, function () {
-      this.workspace.options.readOnly = true;
-      this.injectionDiv.dispatchEvent(keyEvent);
-      sinon.assert.notCalled(this.hideChaffSpy);
-    });
-  }
-
-  suite('Escape', function () {
-    setup(function () {
-      this.event = createKeyDownEvent(Blockly.utils.KeyCodes.ESC);
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-    });
-    test('Simple', function () {
-      this.injectionDiv.dispatchEvent(this.event);
-      sinon.assert.calledOnce(this.hideChaffSpy);
-    });
-    runReadOnlyTest(createKeyDownEvent(Blockly.utils.KeyCodes.ESC));
-    test('Not called when focus is on an HTML input', function () {
-      const event = createKeyDownEvent(Blockly.utils.KeyCodes.ESC);
-      const input = document.createElement('textarea');
-      input.dispatchEvent(event);
-      sinon.assert.notCalled(this.hideChaffSpy);
-    });
-    test('Not called on hidden workspaces', function () {
-      this.workspace.isVisible_ = false;
-      this.injectionDiv.dispatchEvent(this.event);
-      sinon.assert.notCalled(this.hideChaffSpy);
-    });
-  });
-
-  suite('Delete Block', function () {
-    setup(function () {
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-      setSelectedBlock(this.workspace);
-      this.deleteSpy = sinon.spy(Blockly.common.getSelected(), 'dispose');
-    });
-    const testCases = [
-      ['Delete', createKeyDownEvent(Blockly.utils.KeyCodes.DELETE)],
-      ['Backspace', createKeyDownEvent(Blockly.utils.KeyCodes.BACKSPACE)],
-    ];
-    // Delete a block.
-    suite('Simple', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.calledOnce(this.hideChaffSpy);
-          sinon.assert.calledOnce(this.deleteSpy);
-        });
-      });
-    });
-    // Do not delete a block if workspace is in readOnly mode.
-    suite('Not called when readOnly is true', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        runReadOnlyTest(keyEvent, testCaseName);
-      });
-    });
-  });
-
-  suite('Copy', function () {
-    setup(function () {
-      this.block = setSelectedBlock(this.workspace);
-      this.copySpy = sinon.spy(this.block, 'toCopyData');
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-    });
-    const testCases = [
-      [
-        'Control C',
-        createKeyDownEvent(Blockly.utils.KeyCodes.C, [
-          Blockly.utils.KeyCodes.CTRL,
-        ]),
-      ],
-      [
-        'Meta C',
-        createKeyDownEvent(Blockly.utils.KeyCodes.C, [
-          Blockly.utils.KeyCodes.META,
-        ]),
-      ],
-      [
-        'Alt C',
-        createKeyDownEvent(Blockly.utils.KeyCodes.C, [
-          Blockly.utils.KeyCodes.ALT,
-        ]),
-      ],
-    ];
-    // Copy a block.
-    suite('Simple', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.calledOnce(this.copySpy);
-          sinon.assert.calledOnce(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not copy a block if a workspace is in readonly mode.
-    suite('Not called when readOnly is true', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        runReadOnlyTest(keyEvent, testCaseName);
-      });
-    });
-    // Do not copy a block if a gesture is in progress.
-    suite('Gesture in progress', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          sinon.stub(Blockly.Gesture, 'inProgress').returns(true);
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.notCalled(this.copySpy);
-          sinon.assert.notCalled(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not copy a block if is is not deletable.
-    suite('Block is not deletable', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          sinon
-            .stub(Blockly.common.getSelected(), 'isDeletable')
-            .returns(false);
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.notCalled(this.copySpy);
-          sinon.assert.notCalled(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not copy a block if it is not movable.
-    suite('Block is not movable', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          sinon.stub(Blockly.common.getSelected(), 'isMovable').returns(false);
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.notCalled(this.copySpy);
-          sinon.assert.notCalled(this.hideChaffSpy);
-        });
-      });
-    });
-  });
-
-  suite('Undo', function () {
-    setup(function () {
-      this.undoSpy = sinon.spy(this.workspace, 'undo');
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-    });
-    const testCases = [
-      [
-        'Control Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.CTRL,
-        ]),
-      ],
-      [
-        'Meta Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.META,
-        ]),
-      ],
-      [
-        'Alt Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.ALT,
-        ]),
-      ],
-    ];
-    // Undo.
-    suite('Simple', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.calledOnce(this.undoSpy);
-          sinon.assert.calledWith(this.undoSpy, false);
-          sinon.assert.calledOnce(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not undo if a gesture is in progress.
-    suite('Gesture in progress', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          sinon.stub(Blockly.Gesture, 'inProgress').returns(true);
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.notCalled(this.undoSpy);
-          sinon.assert.notCalled(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not undo if the workspace is in readOnly mode.
-    suite('Not called when readOnly is true', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        runReadOnlyTest(keyEvent, testCaseName);
-      });
-    });
-  });
-
-  suite('Redo', function () {
-    setup(function () {
-      this.redoSpy = sinon.spy(this.workspace, 'undo');
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-    });
-    const testCases = [
-      [
-        'Control Shift Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.CTRL,
-          Blockly.utils.KeyCodes.SHIFT,
-        ]),
-      ],
-      [
-        'Meta Shift Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.META,
-          Blockly.utils.KeyCodes.SHIFT,
-        ]),
-      ],
-      [
-        'Alt Shift Z',
-        createKeyDownEvent(Blockly.utils.KeyCodes.Z, [
-          Blockly.utils.KeyCodes.ALT,
-          Blockly.utils.KeyCodes.SHIFT,
-        ]),
-      ],
-    ];
-    // Undo.
-    suite('Simple', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.calledOnce(this.redoSpy);
-          sinon.assert.calledWith(this.redoSpy, true);
-          sinon.assert.calledOnce(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not undo if a gesture is in progress.
-    suite('Gesture in progress', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        test(testCaseName, function () {
-          sinon.stub(Blockly.Gesture, 'inProgress').returns(true);
-          this.injectionDiv.dispatchEvent(keyEvent);
-          sinon.assert.notCalled(this.redoSpy);
-          sinon.assert.notCalled(this.hideChaffSpy);
-        });
-      });
-    });
-    // Do not undo if the workspace is in readOnly mode.
-    suite('Not called when readOnly is true', function () {
-      testCases.forEach(function (testCase) {
-        const testCaseName = testCase[0];
-        const keyEvent = testCase[1];
-        runReadOnlyTest(keyEvent, testCaseName);
-      });
-    });
-  });
-
-  suite('UndoWindows', function () {
-    setup(function () {
-      this.ctrlYEvent = createKeyDownEvent(Blockly.utils.KeyCodes.Y, [
-        Blockly.utils.KeyCodes.CTRL,
-      ]);
-      this.undoSpy = sinon.spy(this.workspace, 'undo');
-      this.hideChaffSpy = sinon.spy(
-        Blockly.WorkspaceSvg.prototype,
-        'hideChaff',
-      );
-    });
-    test('Simple', function () {
-      this.injectionDiv.dispatchEvent(this.ctrlYEvent);
-      sinon.assert.calledOnce(this.undoSpy);
-      sinon.assert.calledWith(this.undoSpy, true);
-      sinon.assert.calledOnce(this.hideChaffSpy);
-    });
-    test('Not called when a gesture is in progress', function () {
-      sinon.stub(Blockly.Gesture, 'inProgress').returns(true);
-      this.injectionDiv.dispatchEvent(this.ctrlYEvent);
-      sinon.assert.notCalled(this.undoSpy);
-      sinon.assert.notCalled(this.hideChaffSpy);
-    });
-    runReadOnlyTest(
-      createKeyDownEvent(Blockly.utils.KeyCodes.Y, [
-        Blockly.utils.KeyCodes.CTRL,
-      ]),
-    );
-  });
-});