scratch-blocks 1.2.0-beta.1 → 1.2.0

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

@@ -1,850 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {assert} from '../../node_modules/chai/chai.js';
-import {ASTNode} from '../../build/src/core/keyboard_nav/ast_node.js';
-import {
-  sharedTestSetup,
-  sharedTestTeardown,
-  workspaceTeardown,
-} from './test_helpers/setup_teardown.js';
-
-suite('ASTNode', function () {
-  setup(function () {
-    sharedTestSetup.call(this);
-    Blockly.defineBlocksWithJsonArray([
-      {
-        'type': 'input_statement',
-        'message0': '%1 %2 %3 %4',
-        'args0': [
-          {
-            'type': 'field_input',
-            'name': 'NAME',
-            'text': 'default',
-          },
-          {
-            'type': 'field_input',
-            'name': 'NAME',
-            'text': 'default',
-          },
-          {
-            'type': 'input_value',
-            'name': 'NAME',
-          },
-          {
-            'type': 'input_statement',
-            'name': 'NAME',
-          },
-        ],
-        'previousStatement': null,
-        'nextStatement': null,
-        'colour': 230,
-        'tooltip': '',
-        'helpUrl': '',
-      },
-      {
-        'type': 'value_input',
-        'message0': '%1',
-        'args0': [
-          {
-            'type': 'input_value',
-            'name': 'NAME',
-          },
-        ],
-        'colour': 230,
-        'tooltip': '',
-        'helpUrl': '',
-      },
-      {
-        'type': 'field_input',
-        'message0': '%1',
-        'args0': [
-          {
-            'type': 'field_input',
-            'name': 'NAME',
-            'text': 'default',
-          },
-        ],
-        'output': null,
-        'colour': 230,
-        'tooltip': '',
-        'helpUrl': '',
-      },
-    ]);
-    this.workspace = new Blockly.Workspace();
-    this.cursor = this.workspace.cursor;
-    const statementInput1 = this.workspace.newBlock('input_statement');
-    const statementInput2 = this.workspace.newBlock('input_statement');
-    const statementInput3 = this.workspace.newBlock('input_statement');
-    const statementInput4 = this.workspace.newBlock('input_statement');
-    const fieldWithOutput = this.workspace.newBlock('field_input');
-    const valueInput = this.workspace.newBlock('value_input');
-
-    statementInput1.nextConnection.connect(statementInput2.previousConnection);
-    statementInput1.inputList[0].connection.connect(
-      fieldWithOutput.outputConnection,
-    );
-    statementInput2.inputList[1].connection.connect(
-      statementInput3.previousConnection,
-    );
-
-    this.blocks = {
-      statementInput1: statementInput1,
-      statementInput2: statementInput2,
-      statementInput3: statementInput3,
-      statementInput4: statementInput4,
-      fieldWithOutput: fieldWithOutput,
-      valueInput: valueInput,
-    };
-  });
-  teardown(function () {
-    sharedTestTeardown.call(this);
-  });
-
-  suite('HelperFunctions', function () {
-    test('findNextForInput', function () {
-      const input = this.blocks.statementInput1.inputList[0];
-      const input2 = this.blocks.statementInput1.inputList[1];
-      const connection = input.connection;
-      const node = ASTNode.createConnectionNode(connection);
-      const newASTNode = node.findNextForInput(input);
-      assert.equal(newASTNode.getLocation(), input2.connection);
-    });
-
-    test('findPrevForInput', function () {
-      const input = this.blocks.statementInput1.inputList[0];
-      const input2 = this.blocks.statementInput1.inputList[1];
-      const connection = input2.connection;
-      const node = ASTNode.createConnectionNode(connection);
-      const newASTNode = node.findPrevForInput(input2);
-      assert.equal(newASTNode.getLocation(), input.connection);
-    });
-
-    test('findNextForField', function () {
-      const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-      const field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
-      const node = ASTNode.createFieldNode(field);
-      const newASTNode = node.findNextForField(field);
-      assert.equal(newASTNode.getLocation(), field2);
-    });
-
-    test('findPrevForField', function () {
-      const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-      const field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
-      const node = ASTNode.createFieldNode(field2);
-      const newASTNode = node.findPrevForField(field2);
-      assert.equal(newASTNode.getLocation(), field);
-    });
-
-    test('navigateBetweenStacks_Forward', function () {
-      const node = new ASTNode(
-        ASTNode.types.NEXT,
-        this.blocks.statementInput1.nextConnection,
-      );
-      const newASTNode = node.navigateBetweenStacks(true);
-      assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
-    });
-
-    test('navigateBetweenStacks_Backward', function () {
-      const node = new ASTNode(
-        ASTNode.types.BLOCK,
-        this.blocks.statementInput4,
-      );
-      const newASTNode = node.navigateBetweenStacks(false);
-      assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
-    });
-    test('getOutAstNodeForBlock', function () {
-      const node = new ASTNode(
-        ASTNode.types.BLOCK,
-        this.blocks.statementInput2,
-      );
-      const newASTNode = node.getOutAstNodeForBlock(
-        this.blocks.statementInput2,
-      );
-      assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
-    });
-    test('getOutAstNodeForBlock_OneBlock', function () {
-      const node = new ASTNode(
-        ASTNode.types.BLOCK,
-        this.blocks.statementInput4,
-      );
-      const newASTNode = node.getOutAstNodeForBlock(
-        this.blocks.statementInput4,
-      );
-      assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
-    });
-    test('findFirstFieldOrInput_', function () {
-      const node = new ASTNode(
-        ASTNode.types.BLOCK,
-        this.blocks.statementInput4,
-      );
-      const field = this.blocks.statementInput4.inputList[0].fieldRow[0];
-      const newASTNode = node.findFirstFieldOrInput(
-        this.blocks.statementInput4,
-      );
-      assert.equal(newASTNode.getLocation(), field);
-    });
-  });
-
-  suite('NavigationFunctions', function () {
-    setup(function () {
-      Blockly.defineBlocksWithJsonArray([
-        {
-          'type': 'top_connection',
-          'message0': '',
-          'previousStatement': null,
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'start_block',
-          'message0': '',
-          'nextStatement': null,
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'fields_and_input',
-          'message0': '%1 hi %2 %3 %4',
-          'args0': [
-            {
-              'type': 'field_input',
-              'name': 'NAME',
-              'text': 'default',
-            },
-            {
-              'type': 'input_dummy',
-            },
-            {
-              'type': 'field_input',
-              'name': 'NAME',
-              'text': 'default',
-            },
-            {
-              'type': 'input_value',
-              'name': 'NAME',
-            },
-          ],
-          'previousStatement': null,
-          'nextStatement': null,
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'two_fields',
-          'message0': '%1 hi',
-          'args0': [
-            {
-              'type': 'field_input',
-              'name': 'NAME',
-              'text': 'default',
-            },
-          ],
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'fields_and_input2',
-          'message0': '%1 %2 %3 hi %4 bye',
-          'args0': [
-            {
-              'type': 'input_value',
-              'name': 'NAME',
-            },
-            {
-              'type': 'field_input',
-              'name': 'NAME',
-              'text': 'default',
-            },
-            {
-              'type': 'input_value',
-              'name': 'NAME',
-            },
-            {
-              'type': 'input_statement',
-              'name': 'NAME',
-            },
-          ],
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'dummy_input',
-          'message0': 'Hello',
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'dummy_inputValue',
-          'message0': 'Hello %1  %2',
-          'args0': [
-            {
-              'type': 'input_dummy',
-            },
-            {
-              'type': 'input_value',
-              'name': 'NAME',
-            },
-          ],
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-        },
-        {
-          'type': 'output_next',
-          'message0': '',
-          'output': null,
-          'colour': 230,
-          'tooltip': '',
-          'helpUrl': '',
-          'nextStatement': null,
-        },
-      ]);
-      const noNextConnection = this.workspace.newBlock('top_connection');
-      const fieldAndInputs = this.workspace.newBlock('fields_and_input');
-      const twoFields = this.workspace.newBlock('two_fields');
-      const fieldAndInputs2 = this.workspace.newBlock('fields_and_input2');
-      const noPrevConnection = this.workspace.newBlock('start_block');
-      this.blocks.noNextConnection = noNextConnection;
-      this.blocks.fieldAndInputs = fieldAndInputs;
-      this.blocks.twoFields = twoFields;
-      this.blocks.fieldAndInputs2 = fieldAndInputs2;
-      this.blocks.noPrevConnection = noPrevConnection;
-
-      const dummyInput = this.workspace.newBlock('dummy_input');
-      const dummyInputValue = this.workspace.newBlock('dummy_inputValue');
-      const fieldWithOutput2 = this.workspace.newBlock('field_input');
-      this.blocks.dummyInput = dummyInput;
-      this.blocks.dummyInputValue = dummyInputValue;
-      this.blocks.fieldWithOutput2 = fieldWithOutput2;
-
-      const secondBlock = this.workspace.newBlock('input_statement');
-      const outputNextBlock = this.workspace.newBlock('output_next');
-      this.blocks.secondBlock = secondBlock;
-      this.blocks.outputNextBlock = outputNextBlock;
-    });
-    suite('Next', function () {
-      setup(function () {
-        this.singleBlockWorkspace = new Blockly.Workspace();
-        const singleBlock = this.singleBlockWorkspace.newBlock('two_fields');
-        this.blocks.singleBlock = singleBlock;
-      });
-      teardown(function () {
-        workspaceTeardown.call(this, this.singleBlockWorkspace);
-      });
-
-      test('fromPreviousToBlock', function () {
-        const prevConnection = this.blocks.statementInput1.previousConnection;
-        const node = ASTNode.createConnectionNode(prevConnection);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromBlockToNext', function () {
-        const nextConnection = this.blocks.statementInput1.nextConnection;
-        const node = ASTNode.createBlockNode(this.blocks.statementInput1);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), nextConnection);
-      });
-      test('fromBlockToNull', function () {
-        const node = ASTNode.createBlockNode(this.blocks.noNextConnection);
-        const nextNode = node.next();
-        assert.isNull(nextNode);
-      });
-      test('fromNextToPrevious', function () {
-        const nextConnection = this.blocks.statementInput1.nextConnection;
-        const prevConnection = this.blocks.statementInput2.previousConnection;
-        const node = ASTNode.createConnectionNode(nextConnection);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), prevConnection);
-      });
-      test('fromNextToNull', function () {
-        const nextConnection = this.blocks.statementInput2.nextConnection;
-        const node = ASTNode.createConnectionNode(nextConnection);
-        const nextNode = node.next();
-        assert.isNull(nextNode);
-      });
-      test('fromInputToInput', function () {
-        const input = this.blocks.statementInput1.inputList[0];
-        const inputConnection =
-          this.blocks.statementInput1.inputList[1].connection;
-        const node = ASTNode.createInputNode(input);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), inputConnection);
-      });
-      test('fromInputToStatementInput', function () {
-        const input = this.blocks.fieldAndInputs2.inputList[1];
-        const inputConnection =
-          this.blocks.fieldAndInputs2.inputList[2].connection;
-        const node = ASTNode.createInputNode(input);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), inputConnection);
-      });
-      test('fromInputToField', function () {
-        const input = this.blocks.fieldAndInputs2.inputList[0];
-        const field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
-        const node = ASTNode.createInputNode(input);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), field);
-      });
-      test('fromInputToNull', function () {
-        const input = this.blocks.fieldAndInputs2.inputList[2];
-        const node = ASTNode.createInputNode(input);
-        const nextNode = node.next();
-        assert.isNull(nextNode);
-      });
-      test('fromOutputToBlock', function () {
-        const output = this.blocks.fieldWithOutput.outputConnection;
-        const node = ASTNode.createConnectionNode(output);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), this.blocks.fieldWithOutput);
-      });
-      test('fromFieldToInput', function () {
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[1];
-        const inputConnection =
-          this.blocks.statementInput1.inputList[0].connection;
-        const node = ASTNode.createFieldNode(field);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), inputConnection);
-      });
-      test('fromFieldToField', function () {
-        const field = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const field2 = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), field2);
-      });
-      test('fromFieldToNull', function () {
-        const field = this.blocks.twoFields.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const nextNode = node.next();
-        assert.isNull(nextNode);
-      });
-      test('fromStackToStack', function () {
-        const node = ASTNode.createStackNode(this.blocks.statementInput1);
-        const nextNode = node.next();
-        assert.equal(nextNode.getLocation(), this.blocks.statementInput4);
-        assert.equal(nextNode.getType(), ASTNode.types.STACK);
-      });
-      test('fromStackToNull', function () {
-        const node = ASTNode.createStackNode(this.blocks.singleBlock);
-        const nextNode = node.next();
-        assert.isNull(nextNode);
-      });
-    });
-
-    suite('Previous', function () {
-      test('fromPreviousToNull', function () {
-        const prevConnection = this.blocks.statementInput1.previousConnection;
-        const node = ASTNode.createConnectionNode(prevConnection);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromPreviousToNext', function () {
-        const prevConnection = this.blocks.statementInput2.previousConnection;
-        const node = ASTNode.createConnectionNode(prevConnection);
-        const prevNode = node.prev();
-        const nextConnection = this.blocks.statementInput1.nextConnection;
-        assert.equal(prevNode.getLocation(), nextConnection);
-      });
-      test('fromPreviousToInput', function () {
-        const prevConnection = this.blocks.statementInput3.previousConnection;
-        const node = ASTNode.createConnectionNode(prevConnection);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromBlockToPrevious', function () {
-        const node = ASTNode.createBlockNode(this.blocks.statementInput1);
-        const prevNode = node.prev();
-        const prevConnection = this.blocks.statementInput1.previousConnection;
-        assert.equal(prevNode.getLocation(), prevConnection);
-      });
-      test('fromBlockToNull', function () {
-        const node = ASTNode.createBlockNode(this.blocks.noPrevConnection);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromBlockToOutput', function () {
-        const node = ASTNode.createBlockNode(this.blocks.fieldWithOutput);
-        const prevNode = node.prev();
-        const outputConnection = this.blocks.fieldWithOutput.outputConnection;
-        assert.equal(prevNode.getLocation(), outputConnection);
-      });
-      test('fromNextToBlock', function () {
-        const nextConnection = this.blocks.statementInput1.nextConnection;
-        const node = ASTNode.createConnectionNode(nextConnection);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromInputToField', function () {
-        const input = this.blocks.statementInput1.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), input.fieldRow[1]);
-      });
-      test('fromInputToNull', function () {
-        const input = this.blocks.fieldAndInputs2.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromInputToInput', function () {
-        const input = this.blocks.fieldAndInputs2.inputList[2];
-        const inputConnection =
-          this.blocks.fieldAndInputs2.inputList[1].connection;
-        const node = ASTNode.createInputNode(input);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), inputConnection);
-      });
-      test('fromOutputToNull', function () {
-        const output = this.blocks.fieldWithOutput.outputConnection;
-        const node = ASTNode.createConnectionNode(output);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromFieldToNull', function () {
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const prevNode = node.prev();
-        assert.isNull(prevNode);
-      });
-      test('fromFieldToInput', function () {
-        const field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
-        const inputConnection =
-          this.blocks.fieldAndInputs2.inputList[0].connection;
-        const node = ASTNode.createFieldNode(field);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), inputConnection);
-      });
-      test('fromFieldToField', function () {
-        const field = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
-        const field2 = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), field2);
-      });
-      test('fromStackToStack', function () {
-        const node = ASTNode.createStackNode(this.blocks.statementInput4);
-        const prevNode = node.prev();
-        assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
-        assert.equal(prevNode.getType(), ASTNode.types.STACK);
-      });
-    });
-
-    suite('In', function () {
-      setup(function () {
-        this.emptyWorkspace = new Blockly.Workspace();
-      });
-      teardown(function () {
-        workspaceTeardown.call(this, this.emptyWorkspace);
-      });
-
-      test('fromInputToOutput', function () {
-        const input = this.blocks.statementInput1.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        const inNode = node.in();
-        const outputConnection = this.blocks.fieldWithOutput.outputConnection;
-        assert.equal(inNode.getLocation(), outputConnection);
-      });
-      test('fromInputToNull', function () {
-        const input = this.blocks.statementInput2.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        const inNode = node.in();
-        assert.isNull(inNode);
-      });
-      test('fromInputToPrevious', function () {
-        const input = this.blocks.statementInput2.inputList[1];
-        const previousConnection =
-          this.blocks.statementInput3.previousConnection;
-        const node = ASTNode.createInputNode(input);
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), previousConnection);
-      });
-      test('fromBlockToInput', function () {
-        const input = this.blocks.valueInput.inputList[0];
-        const node = ASTNode.createBlockNode(this.blocks.valueInput);
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), input.connection);
-      });
-      test('fromBlockToField', function () {
-        const node = ASTNode.createBlockNode(this.blocks.statementInput1);
-        const inNode = node.in();
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        assert.equal(inNode.getLocation(), field);
-      });
-      test('fromBlockToPrevious', function () {
-        const prevConnection = this.blocks.statementInput4.previousConnection;
-        const node = ASTNode.createStackNode(this.blocks.statementInput4);
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), prevConnection);
-        assert.equal(inNode.getType(), ASTNode.types.PREVIOUS);
-      });
-      test('fromBlockToNull_DummyInput', function () {
-        const node = ASTNode.createBlockNode(this.blocks.dummyInput);
-        const inNode = node.in();
-        assert.isNull(inNode);
-      });
-      test('fromBlockToInput_DummyInputValue', function () {
-        const node = ASTNode.createBlockNode(this.blocks.dummyInputValue);
-        const inputConnection =
-          this.blocks.dummyInputValue.inputList[1].connection;
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), inputConnection);
-      });
-      test('fromOuputToNull', function () {
-        const output = this.blocks.fieldWithOutput.outputConnection;
-        const node = ASTNode.createConnectionNode(output);
-        const inNode = node.in();
-        assert.isNull(inNode);
-      });
-      test('fromFieldToNull', function () {
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const inNode = node.in();
-        assert.isNull(inNode);
-      });
-      test('fromWorkspaceToStack', function () {
-        const coordinate = new Blockly.utils.Coordinate(100, 100);
-        const node = ASTNode.createWorkspaceNode(this.workspace, coordinate);
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
-        assert.equal(inNode.getType(), ASTNode.types.STACK);
-      });
-      test('fromWorkspaceToNull', function () {
-        const coordinate = new Blockly.utils.Coordinate(100, 100);
-        const node = ASTNode.createWorkspaceNode(
-          this.emptyWorkspace,
-          coordinate,
-        );
-        const inNode = node.in();
-        assert.isNull(inNode);
-      });
-      test('fromStackToPrevious', function () {
-        const node = ASTNode.createStackNode(this.blocks.statementInput1);
-        const previous = this.blocks.statementInput1.previousConnection;
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), previous);
-        assert.equal(inNode.getType(), ASTNode.types.PREVIOUS);
-      });
-      test('fromStackToOutput', function () {
-        const node = ASTNode.createStackNode(this.blocks.fieldWithOutput2);
-        const output = this.blocks.fieldWithOutput2.outputConnection;
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), output);
-        assert.equal(inNode.getType(), ASTNode.types.OUTPUT);
-      });
-      test('fromStackToBlock', function () {
-        const node = ASTNode.createStackNode(this.blocks.dummyInput);
-        const inNode = node.in();
-        assert.equal(inNode.getLocation(), this.blocks.dummyInput);
-        assert.equal(inNode.getType(), ASTNode.types.BLOCK);
-      });
-    });
-
-    suite('Out', function () {
-      setup(function () {
-        const secondBlock = this.blocks.secondBlock;
-        const outputNextBlock = this.blocks.outputNextBlock;
-        this.blocks.noPrevConnection.nextConnection.connect(
-          secondBlock.previousConnection,
-        );
-        secondBlock.inputList[0].connection.connect(
-          outputNextBlock.outputConnection,
-        );
-      });
-
-      test('fromInputToBlock', function () {
-        const input = this.blocks.statementInput1.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.BLOCK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromOutputToInput', function () {
-        const output = this.blocks.fieldWithOutput.outputConnection;
-        const node = ASTNode.createConnectionNode(output);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(
-          outNode.getLocation(),
-          this.blocks.statementInput1.inputList[0].connection,
-        );
-      });
-      test('fromOutputToStack', function () {
-        const output = this.blocks.fieldWithOutput2.outputConnection;
-        const node = ASTNode.createConnectionNode(output);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.fieldWithOutput2);
-      });
-      test('fromFieldToBlock', function () {
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.BLOCK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromStackToWorkspace', function () {
-        const stub = sinon
-          .stub(this.blocks.statementInput4, 'getRelativeToSurfaceXY')
-          .returns({x: 10, y: 10});
-        const node = ASTNode.createStackNode(this.blocks.statementInput4);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.WORKSPACE);
-        assert.equal(outNode.wsCoordinate.x, 10);
-        assert.equal(outNode.wsCoordinate.y, -10);
-        stub.restore();
-      });
-      test('fromPreviousToInput', function () {
-        const previous = this.blocks.statementInput3.previousConnection;
-        const inputConnection =
-          this.blocks.statementInput2.inputList[1].connection;
-        const node = ASTNode.createConnectionNode(previous);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(outNode.getLocation(), inputConnection);
-      });
-      test('fromPreviousToStack', function () {
-        const previous = this.blocks.statementInput2.previousConnection;
-        const node = ASTNode.createConnectionNode(previous);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromNextToInput', function () {
-        const next = this.blocks.statementInput3.nextConnection;
-        const inputConnection =
-          this.blocks.statementInput2.inputList[1].connection;
-        const node = ASTNode.createConnectionNode(next);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(outNode.getLocation(), inputConnection);
-      });
-      test('fromNextToStack', function () {
-        const next = this.blocks.statementInput2.nextConnection;
-        const node = ASTNode.createConnectionNode(next);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromNextToStack_NoPreviousConnection', function () {
-        const next = this.blocks.secondBlock.nextConnection;
-        const node = ASTNode.createConnectionNode(next);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.noPrevConnection);
-      });
-      /**
-       * This is where there is a block with both an output connection and a
-       * next connection attached to an input.
-       */
-      test('fromNextToInput_OutputAndPreviousConnection', function () {
-        const next = this.blocks.outputNextBlock.nextConnection;
-        const node = ASTNode.createConnectionNode(next);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(
-          outNode.getLocation(),
-          this.blocks.secondBlock.inputList[0].connection,
-        );
-      });
-      test('fromBlockToStack', function () {
-        const node = ASTNode.createBlockNode(this.blocks.statementInput2);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromBlockToInput', function () {
-        const input = this.blocks.statementInput2.inputList[1].connection;
-        const node = ASTNode.createBlockNode(this.blocks.statementInput3);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(outNode.getLocation(), input);
-      });
-      test('fromTopBlockToStack', function () {
-        const node = ASTNode.createBlockNode(this.blocks.statementInput1);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.statementInput1);
-      });
-      test('fromBlockToStack_OutputConnection', function () {
-        const node = ASTNode.createBlockNode(this.blocks.fieldWithOutput2);
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.STACK);
-        assert.equal(outNode.getLocation(), this.blocks.fieldWithOutput2);
-      });
-      test('fromBlockToInput_OutputConnection', function () {
-        const node = ASTNode.createBlockNode(this.blocks.outputNextBlock);
-        const inputConnection = this.blocks.secondBlock.inputList[0].connection;
-        const outNode = node.out();
-        assert.equal(outNode.getType(), ASTNode.types.INPUT);
-        assert.equal(outNode.getLocation(), inputConnection);
-      });
-    });
-
-    suite('createFunctions', function () {
-      test('createFieldNode', function () {
-        const field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        const node = ASTNode.createFieldNode(field);
-        assert.equal(node.getLocation(), field);
-        assert.equal(node.getType(), ASTNode.types.FIELD);
-        assert.isFalse(node.isConnection());
-      });
-      test('createConnectionNode', function () {
-        const prevConnection = this.blocks.statementInput4.previousConnection;
-        const node = ASTNode.createConnectionNode(prevConnection);
-        assert.equal(node.getLocation(), prevConnection);
-        assert.equal(node.getType(), ASTNode.types.PREVIOUS);
-        assert.isTrue(node.isConnection());
-      });
-      test('createInputNode', function () {
-        const input = this.blocks.statementInput1.inputList[0];
-        const node = ASTNode.createInputNode(input);
-        assert.equal(node.getLocation(), input.connection);
-        assert.equal(node.getType(), ASTNode.types.INPUT);
-        assert.isTrue(node.isConnection());
-      });
-      test('createWorkspaceNode', function () {
-        const coordinate = new Blockly.utils.Coordinate(100, 100);
-        const node = ASTNode.createWorkspaceNode(this.workspace, coordinate);
-        assert.equal(node.getLocation(), this.workspace);
-        assert.equal(node.getType(), ASTNode.types.WORKSPACE);
-        assert.equal(node.getWsCoordinate(), coordinate);
-        assert.isFalse(node.isConnection());
-      });
-      test('createStatementConnectionNode', function () {
-        const nextConnection =
-          this.blocks.statementInput1.inputList[1].connection;
-        const inputConnection =
-          this.blocks.statementInput1.inputList[1].connection;
-        const node = ASTNode.createConnectionNode(nextConnection);
-        assert.equal(node.getLocation(), inputConnection);
-        assert.equal(node.getType(), ASTNode.types.INPUT);
-        assert.isTrue(node.isConnection());
-      });
-      test('createTopNode-previous', function () {
-        const block = this.blocks.statementInput1;
-        const topNode = ASTNode.createTopNode(block);
-        assert.equal(topNode.getLocation(), block.previousConnection);
-      });
-      test('createTopNode-block', function () {
-        const block = this.blocks.noPrevConnection;
-        const topNode = ASTNode.createTopNode(block);
-        assert.equal(topNode.getLocation(), block);
-      });
-      test('createTopNode-output', function () {
-        const block = this.blocks.outputNextBlock;
-        const topNode = ASTNode.createTopNode(block);
-        assert.equal(topNode.getLocation(), block.outputConnection);
-      });
-    });
-  });
-});