blockly/tests/mocha/generator_test.js

/**
 * @license
 * Copyright 2020 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

goog.declareModuleId('Blockly.test.generator');

import * as Blockly from '../../build/src/core/blockly.js';
const {dartGenerator} = goog.require('Blockly.Dart');
const {javascriptGenerator} = goog.require('Blockly.JavaScript');
const {luaGenerator} = goog.require('Blockly.Lua');
const {phpGenerator} = goog.require('Blockly.PHP');
const {pythonGenerator} = goog.require('Blockly.Python');
import {
  sharedTestSetup,
  sharedTestTeardown,
} from './test_helpers/setup_teardown.js';

suite('Generator', function () {
  setup(function () {
    sharedTestSetup.call(this);
    this.workspace = new Blockly.Workspace();
  });

  teardown(function () {
    sharedTestTeardown.call(this);
  });

  suite('prefix', function () {
    setup(function () {
      this.generator = new Blockly.CodeGenerator('INTERCAL');
    });

    test('Nothing', function () {
      chai.assert.equal(this.generator.prefixLines('', ''), '');
    });

    test('One word', function () {
      chai.assert.equal(this.generator.prefixLines('Hello', '@'), '@Hello');
    });

    test('One line', function () {
      chai.assert.equal(
        this.generator.prefixLines('Hello\n', '12'),
        '12Hello\n'
      );
    });

    test('Two lines', function () {
      chai.assert.equal(
        this.generator.prefixLines('Hello\nWorld\n', '***'),
        '***Hello\n***World\n'
      );
    });
  });

  suite('blockToCode', function () {
    setup(function () {
      Blockly.defineBlocksWithJsonArray([
        {
          'type': 'stack_block',
          'message0': '',
          'previousStatement': null,
          'nextStatement': null,
        },
        {
          'type': 'row_block',
          'message0': '%1',
          'args0': [
            {
              'type': 'input_value',
              'name': 'INPUT',
            },
          ],
          'output': null,
          'nextStatement': null,
        },
      ]);
      const rowBlock = this.workspace.newBlock('row_block');
      const stackBlock = this.workspace.newBlock('stack_block');

      this.blockToCodeTest = function (
        generator,
        blockDisabled,
        opt_thisOnly,
        expectedCode,
        opt_message
      ) {
        generator.row_block = function (_) {
          return 'row_block';
        };
        generator.stack_block = function (_) {
          return 'stack_block';
        };
        rowBlock.nextConnection.connect(stackBlock.previousConnection);
        rowBlock.disabled = blockDisabled;

        const code = generator.blockToCode(rowBlock, opt_thisOnly);
        chai.assert.equal(code, expectedCode, opt_message);
      };
    });

    const testCase = [
      [dartGenerator, 'Dart'],
      [javascriptGenerator, 'JavaScript'],
      [luaGenerator, 'Lua'],
      [phpGenerator, 'PHP'],
      [pythonGenerator, 'Python'],
    ];

    suite('Trivial', function () {
      testCase.forEach(function (testCase) {
        const generator = testCase[0];
        const name = testCase[1];
        test(name, function () {
          generator.init(this.workspace);
          this.blockToCodeTest(generator, false, true, 'row_block');
          this.blockToCodeTest(
            generator,
            false,
            false,
            'row_blockstack_block',
            'thisOnly=false'
          );
        });
      });
    });

    suite('Disabled block', function () {
      testCase.forEach(function (testCase) {
        const generator = testCase[0];
        const name = testCase[1];
        test(name, function () {
          this.blockToCodeTest(generator, true, true, '');
          this.blockToCodeTest(
            generator,
            true,
            false,
            'stack_block',
            'thisOnly=false'
          );
        });
      });
    });

    suite('Nested block', function () {
      setup(function () {
        Blockly.defineBlocksWithJsonArray([
          {
            'type': 'test_loop_block',
            'message0': 'Repeat Loop',
            'message1': '%1',
            'args1': [
              {
                'type': 'input_statement',
                'name': 'DO',
              },
            ],
            'previousStatement': null,
            'nextStatement': null,
          },
        ]);
        const blockA = this.workspace.newBlock('test_loop_block');
        const blockB = this.workspace.newBlock('test_loop_block');
        const blockC = this.workspace.newBlock('test_loop_block');
        this.loopTest = function (
          generator,
          opt_thisOnly,
          expectedCode,
          opt_message
        ) {
          generator.test_loop_block = function (block) {
            return '{' + generator.statementToCode(block, 'DO') + '}';
          };
          blockA.getInput('DO').connection.connect(blockB.previousConnection);
          blockA.nextConnection.connect(blockC.previousConnection);

          const code = generator.blockToCode(blockA, opt_thisOnly);
          chai.assert.equal(code, expectedCode, opt_message);
        };
      });

      testCase.forEach(function (testCase) {
        const generator = testCase[0];
        const name = testCase[1];
        test(name, function () {
          this.loopTest(generator, true, '{  {}}');
          this.loopTest(generator, false, '{  {}}{}', 'thisOnly=false');
        });
      });
    });
  });
});