mirror of
https://github.com/google/blockly.git
synced 2026-01-10 02:17:09 +01:00
Added More Procedure Unit Tests (#2630)
* Added more procedure unit tests. * Cleanup from rebase. * Cleanup.
This commit is contained in:
Beka Westberg
committed by
alschmiedt
alschmiedt
parent
ec34698c53
commit
093467aed1
@@ -483,6 +483,9 @@ Blockly.Blocks['procedures_mutatorcontainer'] = {
|
||||
this.setTooltip(Blockly.Msg['PROCEDURES_MUTATORCONTAINER_TOOLTIP']);
|
||||
this.contextMenu = false;
|
||||
},
|
||||
|
||||
// TODO: Move this to a validator on the arg blocks, that way it can be
|
||||
// tested.
|
||||
/**
|
||||
* This will create & delete variables and in dialogs workspace to ensure
|
||||
* that when a new block is dragged out it will have a unique parameter name.
|
||||
|
||||
@@ -55,6 +55,7 @@
|
||||
<script src="theme_test.js"></script>
|
||||
<script src="trashcan_test.js"></script>
|
||||
<script src="utils_test.js"></script>
|
||||
<script src="xml_procedures_test.js"></script>
|
||||
<script src="xml_test.js"></script>
|
||||
|
||||
<div id="blocklyDiv"></div>
|
||||
|
||||
@@ -123,7 +123,6 @@ suite('Procedures', function() {
|
||||
|
||||
defInput.htmlInput_.value = 'start name';
|
||||
defInput.onHtmlInputChange_(null);
|
||||
console.log(this.defType);
|
||||
chai.assert.equal(this.defBlock.getFieldValue('NAME'), 'start name');
|
||||
chai.assert.equal(this.callBlock.getFieldValue('NAME'), 'start name');
|
||||
}, 'START NAME');
|
||||
@@ -312,7 +311,7 @@ suite('Procedures', function() {
|
||||
}, 'name');
|
||||
});
|
||||
});
|
||||
suite('Arguments', function() {
|
||||
suite('Mutation', function() {
|
||||
setup(function() {
|
||||
this.findParentStub = sinon.stub(Blockly.Mutator, 'findParentWs')
|
||||
.returns(this.workspace);
|
||||
@@ -320,110 +319,242 @@ suite('Procedures', function() {
|
||||
teardown(function() {
|
||||
this.findParentStub.restore();
|
||||
});
|
||||
suite('Untyped Arguments', function() {
|
||||
function createMutator(argArray) {
|
||||
this.mutatorWorkspace = new Blockly.Workspace();
|
||||
this.containerBlock = this.defBlock.decompose(this.mutatorWorkspace);
|
||||
this.connection = this.containerBlock.getInput('STACK').connection;
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
this.argBlock = new Blockly.Block(
|
||||
this.mutatorWorkspace, 'procedures_mutatorarg');
|
||||
this.argBlock.setFieldValue(argArray[i], 'NAME');
|
||||
this.connection.connect(this.argBlock.previousConnection);
|
||||
this.connection = this.argBlock.nextConnection;
|
||||
suite('Composition', function() {
|
||||
suite('Statements', function() {
|
||||
function setStatementValue(defBlock, value) {
|
||||
var mutatorWorkspace = new Blockly.Workspace();
|
||||
defBlock.decompose(mutatorWorkspace);
|
||||
var containerBlock = mutatorWorkspace.getTopBlocks()[0];
|
||||
var statementField = containerBlock.getField('STATEMENTS');
|
||||
statementField.setValue(value);
|
||||
defBlock.compose(containerBlock);
|
||||
}
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
}
|
||||
function assertArgs(argArray) {
|
||||
chai.assert.equal(this.defBlock.arguments_.length, argArray.length);
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
chai.assert.equal(this.defBlock.arguments_[i], argArray[i]);
|
||||
test('Has Statements', function() {
|
||||
var defBlock = new Blockly.Block(this.workspace, 'procedures_defreturn');
|
||||
setStatementValue(defBlock, true);
|
||||
chai.assert.isTrue(defBlock.hasStatements_);
|
||||
});
|
||||
test('Has No Statements', function() {
|
||||
var defBlock = new Blockly.Block(this.workspace, 'procedures_defreturn');
|
||||
setStatementValue(defBlock, false);
|
||||
chai.assert.isFalse(defBlock.hasStatements_);
|
||||
});
|
||||
test('Saving Statements', function() {
|
||||
var blockXml = Blockly.Xml.textToDom(
|
||||
'<block type="procedures_defreturn">' +
|
||||
' <statement name="STACK">' +
|
||||
' <block type="procedures_ifreturn" id="test"></block>' +
|
||||
' </statement>' +
|
||||
'</block>'
|
||||
);
|
||||
var defBlock = Blockly.Xml.domToBlock(blockXml, this.workspace);
|
||||
setStatementValue(defBlock, false);
|
||||
chai.assert.isNull(defBlock.getInput('STACK'));
|
||||
setStatementValue(defBlock, true);
|
||||
chai.assert.isNotNull(defBlock.getInput('STACK'));
|
||||
var statementBlocks = defBlock.getChildren();
|
||||
chai.assert.equal(statementBlocks.length, 1);
|
||||
var block = statementBlocks[0];
|
||||
chai.assert.equal(block.type, 'procedures_ifreturn');
|
||||
chai.assert.equal(block.id, 'test');
|
||||
});
|
||||
});
|
||||
suite('Untyped Arguments', function() {
|
||||
function createMutator(argArray) {
|
||||
this.mutatorWorkspace = new Blockly.Workspace();
|
||||
this.containerBlock = this.defBlock.decompose(this.mutatorWorkspace);
|
||||
this.connection = this.containerBlock.getInput('STACK').connection;
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
this.argBlock = new Blockly.Block(
|
||||
this.mutatorWorkspace, 'procedures_mutatorarg');
|
||||
this.argBlock.setFieldValue(argArray[i], 'NAME');
|
||||
this.connection.connect(this.argBlock.previousConnection);
|
||||
this.connection = this.argBlock.nextConnection;
|
||||
}
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
}
|
||||
chai.assert.equal(this.callBlock.arguments_.length, argArray.length);
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
chai.assert.equal(this.callBlock.arguments_[i], argArray[i]);
|
||||
function assertArgs(argArray) {
|
||||
chai.assert.equal(this.defBlock.arguments_.length, argArray.length);
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
chai.assert.equal(this.defBlock.arguments_[i], argArray[i]);
|
||||
}
|
||||
chai.assert.equal(this.callBlock.arguments_.length, argArray.length);
|
||||
for (var i = 0; i < argArray.length; i++) {
|
||||
chai.assert.equal(this.callBlock.arguments_[i], argArray[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
function clearVariables() {
|
||||
// TODO: Update this for typed vars.
|
||||
var variables = this.workspace.getVariablesOfType('');
|
||||
var variableMap = this.workspace.getVariableMap();
|
||||
for (var i = 0, variable; variable = variables[i]; i++) {
|
||||
variableMap.deleteVariable(variable);
|
||||
function clearVariables() {
|
||||
// TODO: Update this for typed vars.
|
||||
var variables = this.workspace.getVariablesOfType('');
|
||||
var variableMap = this.workspace.getVariableMap();
|
||||
for (var i = 0, variable; variable = variables[i]; i++) {
|
||||
variableMap.deleteVariable(variable);
|
||||
}
|
||||
}
|
||||
}
|
||||
test('Simple Add Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
test('Simple Add Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
// TODO: Reenable the following two once arg name validation has been
|
||||
// moved to the arg blocks.
|
||||
test.skip('Add Identical Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['x', 'x'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, ['x', 'i']);
|
||||
clearVariables.call(this);
|
||||
});
|
||||
});
|
||||
test.skip('Add Identical (except case) Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['x', 'X'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, ['x', 'i']);
|
||||
clearVariables.call(this);
|
||||
});
|
||||
});
|
||||
test('Multiple Args', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1', 'arg2', 'arg3'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('Simple Change Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg1']);
|
||||
this.argBlock.setFieldValue('arg2', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['arg2']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('lower -> CAPS', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg']);
|
||||
this.argBlock.setFieldValue('ARG', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['ARG']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('CAPS -> lower', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['ARG']);
|
||||
this.argBlock.setFieldValue('arg', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['arg']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
// Test case for #1958
|
||||
test('Set Arg Empty', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
this.argBlock.setFieldValue('', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('Whitespace', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
this.argBlock.setFieldValue(' ', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('Whitespace and Text', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg1']);
|
||||
this.argBlock.setFieldValue(' text ', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['text']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('<>', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['<>'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
});
|
||||
test('Multiple Args', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1', 'arg2', 'arg3'];
|
||||
createMutator.call(this, args);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
suite('Decomposition', function() {
|
||||
suite('Statements', function() {
|
||||
test('Has Statement Input', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var mutatorWorkspace = new Blockly.Workspace();
|
||||
this.defBlock.decompose(mutatorWorkspace);
|
||||
var statementInput = mutatorWorkspace.getTopBlocks()[0]
|
||||
.getInput('STATEMENT_INPUT');
|
||||
if (this.defType == 'procedures_defreturn') {
|
||||
chai.assert.isNotNull(statementInput);
|
||||
} else {
|
||||
chai.assert.isNull(statementInput);
|
||||
}
|
||||
}, 'name');
|
||||
});
|
||||
test('Has Statements', function() {
|
||||
var defBlock = new Blockly.Block(this.workspace, 'procedures_defreturn');
|
||||
defBlock.hasStatements_ = true;
|
||||
var mutatorWorkspace = new Blockly.Workspace();
|
||||
defBlock.decompose(mutatorWorkspace);
|
||||
var statementValue = mutatorWorkspace.getTopBlocks()[0]
|
||||
.getField('STATEMENTS').getValueBoolean();
|
||||
chai.assert.isTrue(statementValue);
|
||||
});
|
||||
test('No Has Statements', function() {
|
||||
var defBlock = new Blockly.Block(this.workspace, 'procedures_defreturn');
|
||||
defBlock.hasStatements_ = false;
|
||||
var mutatorWorkspace = new Blockly.Workspace();
|
||||
defBlock.decompose(mutatorWorkspace);
|
||||
var statementValue = mutatorWorkspace.getTopBlocks()[0]
|
||||
.getField('STATEMENTS').getValueBoolean();
|
||||
chai.assert.isFalse(statementValue);
|
||||
});
|
||||
});
|
||||
test('Simple Change Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg1']);
|
||||
this.argBlock.setFieldValue('arg2', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['arg2']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('lower -> CAPS', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg']);
|
||||
this.argBlock.setFieldValue('ARG', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['ARG']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('CAPS -> lower', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['ARG']);
|
||||
this.argBlock.setFieldValue('arg', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['arg']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
// Test case for #1958
|
||||
test('Set Arg Empty', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
this.argBlock.setFieldValue('', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('Whitespace', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var args = ['arg1'];
|
||||
createMutator.call(this, args);
|
||||
this.argBlock.setFieldValue(' ', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, args);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
});
|
||||
test('Whitespace and Text', function() {
|
||||
this.callForAllTypes(function() {
|
||||
createMutator.call(this, ['arg1']);
|
||||
this.argBlock.setFieldValue(' text ', 'NAME');
|
||||
this.defBlock.compose(this.containerBlock);
|
||||
assertArgs.call(this, ['text']);
|
||||
clearVariables.call(this);
|
||||
}, 'name');
|
||||
suite('Untyped Arguments', function() {
|
||||
function assertArguments(argumentsArray) {
|
||||
this.defBlock.arguments_ = argumentsArray;
|
||||
var mutatorWorkspace = new Blockly.Workspace();
|
||||
this.defBlock.decompose(mutatorWorkspace);
|
||||
var argBlocks = mutatorWorkspace.getBlocksByType('procedures_mutatorarg');
|
||||
chai.assert.equal(argBlocks.length, argumentsArray.length);
|
||||
|
||||
for (var i = 0; i < argumentsArray.length; i++) {
|
||||
var argString = argumentsArray[i];
|
||||
var argBlockValue = argBlocks[i].getFieldValue('NAME');
|
||||
chai.assert.equal(argBlockValue, argString);
|
||||
}
|
||||
}
|
||||
test('Simple Single Arg', function() {
|
||||
this.callForAllTypes(function() {
|
||||
assertArguments.call(this, ['arg']);
|
||||
}, 'name');
|
||||
});
|
||||
test('Multiple Args', function() {
|
||||
this.callForAllTypes(function() {
|
||||
assertArguments.call(this, ['arg1', 'arg2']);
|
||||
}, 'name');
|
||||
});
|
||||
test('<>', function() {
|
||||
this.callForAllTypes(function() {
|
||||
assertArguments.call(this, ['<>']);
|
||||
}, 'name');
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
320
tests/mocha/xml_procedures_test.js
Normal file
320
tests/mocha/xml_procedures_test.js
Normal file
@@ -0,0 +1,320 @@
|
||||
/**
|
||||
* @license
|
||||
* Blockly Tests
|
||||
*
|
||||
* Copyright 2019 Google Inc.
|
||||
* https://developers.google.com/blockly/
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
goog.require('Blockly.Blocks.procedures');
|
||||
goog.require('Blockly.Msg.en');
|
||||
|
||||
suite('Procedures XML', function() {
|
||||
suite('Deserialization', function() {
|
||||
setup(function() {
|
||||
Blockly.setTheme(new Blockly.Theme({
|
||||
"procedure_blocks": {
|
||||
"colourPrimary": "290"
|
||||
}
|
||||
}));
|
||||
this.workspace = new Blockly.Workspace();
|
||||
|
||||
this.callForAllTypes = function(func) {
|
||||
var typesArray = [
|
||||
['procedures_defnoreturn', 'procedures_callnoreturn'],
|
||||
['procedures_defreturn', 'procedures_callreturn']
|
||||
];
|
||||
|
||||
for (var i = 0, types; types = typesArray[i]; i++) {
|
||||
var context = Object.create(null);
|
||||
context.workspace = this.workspace;
|
||||
context.defType = types[0];
|
||||
context.callType = types[1];
|
||||
|
||||
func.call(context);
|
||||
|
||||
this.workspace.clear();
|
||||
}
|
||||
};
|
||||
});
|
||||
teardown(function() {
|
||||
this.workspace.dispose();
|
||||
});
|
||||
|
||||
suite('Definition Blocks', function() {
|
||||
test('Minimal', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '"></block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
// TODO: Is this how you want this to work? or do you want it to
|
||||
// be 'unnamed'?
|
||||
chai.assert.equal(block.getFieldValue('NAME'), '');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
// This is like what's in the toolbox.
|
||||
test('Common', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
test('Arg Vars Pre-Created', function() {
|
||||
this.callForAllTypes(function() {
|
||||
this.workspace.createVariable('x', '', 'arg');
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.deepEqual(block.arguments_, ['x']);
|
||||
chai.assert.deepEqual(block.argumentVarModels_,
|
||||
[this.workspace.getVariableById('arg')]);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
test('Arg Vars Not Created', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.deepEqual(block.arguments_, ['x']);
|
||||
chai.assert.deepEqual(block.argumentVarModels_,
|
||||
[this.workspace.getVariableById('arg')]);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
// TODO: I don't know a lot about typing vars, and even less out it in
|
||||
// this context. Is allowing typed vars to be args the correct behavior?
|
||||
test('Arg Vars Pre-Created Typed', function() {
|
||||
this.callForAllTypes(function() {
|
||||
this.workspace.createVariable('x', 'type', 'arg');
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.deepEqual(block.arguments_, ['x']);
|
||||
chai.assert.deepEqual(block.argumentVarModels_,
|
||||
[this.workspace.getVariableById('arg')]);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
test('Statements False', function() {
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="procedures_defreturn">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation statements="false"></mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);
|
||||
chai.assert.isNull(block.getInput('STACK'));
|
||||
});
|
||||
test('Statements True', function() {
|
||||
var xml = Blockly.Xml.textToDom(
|
||||
'<block type="procedures_defreturn">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation statements="true"></mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(xml, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);
|
||||
chai.assert.isNotNull(block.getInput('STACK'));
|
||||
});
|
||||
});
|
||||
suite('Call Blocks', function() {
|
||||
test('Caller W/ Def', function() {
|
||||
this.callForAllTypes(function() {
|
||||
Blockly.Xml.domToBlock(Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
'</block>'
|
||||
), this.workspace);
|
||||
var callerXML = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.callType + '">' +
|
||||
' <mutation name="do something"/>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(callerXML, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
// TODO: argumentVarModels_ is undefined for call_return, but
|
||||
// defined for call_noreturn. Make it defined for both.
|
||||
/*chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);*/
|
||||
});
|
||||
});
|
||||
// TODO: I couldn't get this test (of creating a definition) to work
|
||||
// b/c of the events delay.
|
||||
test.skip('Caller No Def', function() {
|
||||
this.callForAllTypes(function() {
|
||||
var callerXML = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.callType + '">' +
|
||||
' <mutation name="do something"/>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(callerXML, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.isArray(block.arguments_);
|
||||
chai.assert.isEmpty(block.arguments_);
|
||||
// TODO: argumentVarModels_ is undefined for call_return, but
|
||||
// defined for call_noreturn. Make it defined for both.
|
||||
/*chai.assert.isArray(block.argumentVarModels_);
|
||||
chai.assert.isEmpty(block.argumentVarModels_);*/
|
||||
chai.assert.equal(this.workspace.getAllBlocks().count, 2);
|
||||
});
|
||||
});
|
||||
test('Caller W/ Params', function() {
|
||||
this.callForAllTypes(function() {
|
||||
Blockly.Xml.domToBlock(Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
), this.workspace);
|
||||
var callerXML = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.callType + '">' +
|
||||
' <mutation name="do something">' +
|
||||
' <arg name="x"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
var block = Blockly.Xml.domToBlock(callerXML, this.workspace);
|
||||
|
||||
chai.assert.equal(
|
||||
block.getFieldValue('NAME'),
|
||||
'do something');
|
||||
chai.assert.deepEqual(block.arguments_, ['x']);
|
||||
chai.assert.deepEqual(block.argumentVarModels_,
|
||||
[this.workspace.getVariableById('arg')]);
|
||||
});
|
||||
});
|
||||
// TODO: How do you want it to behave in this situation?
|
||||
test.skip('Caller W/out Params', function() {
|
||||
this.callForAllTypes(function() {
|
||||
Blockly.Xml.domToBlock(Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
), this.workspace);
|
||||
var callerXML = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.callType + '">' +
|
||||
' <mutation name="do something"></mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
// TODO: Remove this when you fix this test.
|
||||
// eslint-disable-next-line no-unused-vars
|
||||
var block = Blockly.Xml.domToBlock(callerXML, this.workspace);
|
||||
});
|
||||
});
|
||||
// TODO: How do you want it to behave in this situation?
|
||||
test.skip('Caller W/ Bad Params', function() {
|
||||
this.callForAllTypes(function() {
|
||||
Blockly.Xml.domToBlock(Blockly.Xml.textToDom(
|
||||
'<block type="' + this.defType + '">' +
|
||||
' <field name="NAME">do something</field>' +
|
||||
' <mutation>' +
|
||||
' <arg name="x" varid="arg"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
), this.workspace);
|
||||
var callerXML = Blockly.Xml.textToDom(
|
||||
'<block type="' + this.callType + '">' +
|
||||
' <mutation name="do something">' +
|
||||
' <arg name="y"></arg>' +
|
||||
' </mutation>' +
|
||||
'</block>'
|
||||
);
|
||||
// TODO: Remove this when you fix this test.
|
||||
// eslint-disable-next-line no-unused-vars
|
||||
var block = Blockly.Xml.domToBlock(callerXML, this.workspace);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user