CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-11 19:07:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

Converting jsunit asserts to chai. (#3831)

Browse Source 
* Converting jsunit asserts to chai.

* Move jsunit functions to test_utilities.

* Adding eslint exception for helper method.
This commit is contained in:
Monica Kozbial
2020-04-17 16:08:46 -07:00
committed by GitHub
parent cfa198c6a0
commit 0adf7efd5f
32 changed files with 741 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
tests/jsunit/test_utilities.js
View File

@@ -158,3 +158,124 @@ function captureWarnings(innerFunc) {
}
return msgs;
}
function _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) {
return args.length == expectedNumberOfNonCommentArgs + 1;
}
function _commentArg(expectedNumberOfNonCommentArgs, args) {
if (_argumentsIncludeComments(expectedNumberOfNonCommentArgs, args)) {
return args[0];
}
return null;
}
function _nonCommentArg(desiredNonCommentArgIndex, expectedNumberOfNonCommentArgs, args) {
return _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) ?
args[desiredNonCommentArgIndex] :
args[desiredNonCommentArgIndex - 1];
}
function _validateArguments(expectedNumberOfNonCommentArgs, args) {
if (!( args.length == expectedNumberOfNonCommentArgs ||
(args.length == expectedNumberOfNonCommentArgs + 1 && (typeof(args[0]) == 'string') || args[0] == null))) {
throw Error('Incorrect arguments passed to assert function');
}
}
/**
* Converts from JSUnit assertEquals to chai.assert.equal.
*/
function assertEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
var comment = _commentArg(2, arguments);
chai.assert.equal(var1, var2, comment);
}
/**
* Converts from JSUnit assertNotEquals to chai.assert.notEquals.
*/
function assertNotEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
var comment = _commentArg(2, arguments);
chai.assert.notEqual(var1, var2, comment);
}
/**
* Converts from JSUnit assertTrue to chai.assert.isTrue.
*/
function assertTrue() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var booleanValue = _nonCommentArg(1, 1, arguments);
if (typeof(booleanValue) != 'boolean') {
throw Error('Bad argument to assertTrue(boolean)');
}
chai.assert.isTrue(booleanValue, commentArg);
}
/**
* Converts from JSUnit assertFalse to chai.assert.isNotTrue.
*/
function assertFalse() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var booleanValue = _nonCommentArg(1, 1, arguments);
if (typeof(booleanValue) != 'boolean') {
throw Error('Bad argument to assertFalse(boolean)');
}
chai.assert.isNotTrue(booleanValue, commentArg);
}
/**
* Converts from JSUnit assertNull to chai.assert.isNull.
*/
function assertNull() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isNull(val, commentArg);
}
function assertNotNull() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isNotNull(val, commentArg);
}
function assertNotNullNorUndefined() {
assertNotNull(arguments);
}
function assert() {
chai.assert(arguments);
}
function assertUndefined() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isUndefined(val, commentArg);
}
function assertNotUndefined() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isDefined(val, commentArg);
}
function assertArrayEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
isEqualArrays(var1, var2);
}

16
tests/mocha/.eslintrc.json
View File

@@ -6,22 +6,12 @@
"globals": {
"chai": false,
"sinon": false,
"assert": true,
"assertArrayEquals": true,
"assertNull": true,
"assertNotNull": true,
"assertEquals": true,
"assertTrue": true,
"assertFalse": true,
"isEqualArrays": true,
"assertUndefined": true,
"assertNotUndefined": true,
"assertNotNullNorUndefined": true,
"assertVariableValues": true,
"defineStackBlock": true,
"createTestBlock": true,
"defineRowBlock": true,
"defineStatementBlock": true,
"createTestBlock": true
"defineStackBlock": true,
"defineStatementBlock": true
},
"extends": "../../.eslintrc.json"
}

160
tests/mocha/astnode_test.js
View File

@@ -105,7 +105,7 @@ suite('ASTNode', function() {
var connection = input.connection;
var node = Blockly.ASTNode.createConnectionNode(connection);
var newASTNode = node.findNextForInput_(input);
assertEquals(newASTNode.getLocation(), input2.connection);
chai.assert.equal(newASTNode.getLocation(), input2.connection);
});
test('findPrevForInput_', function() {
@@ -114,7 +114,7 @@ suite('ASTNode', function() {
var connection = input2.connection;
var node = Blockly.ASTNode.createConnectionNode(connection);
var newASTNode = node.findPrevForInput_(input2);
assertEquals(newASTNode.getLocation(), input.connection);
chai.assert.equal(newASTNode.getLocation(), input.connection);
});
test('findNextForField_', function() {
@@ -122,7 +122,7 @@ suite('ASTNode', function() {
var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
var node = Blockly.ASTNode.createFieldNode(field);
var newASTNode = node.findNextForField_(field);
assertEquals(newASTNode.getLocation(), field2);
chai.assert.equal(newASTNode.getLocation(), field2);
});
test('findPrevForField_', function() {
@@ -130,40 +130,40 @@ suite('ASTNode', function() {
var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
var node = Blockly.ASTNode.createFieldNode(field2);
var newASTNode = node.findPrevForField_(field2);
assertEquals(newASTNode.getLocation(), field);
chai.assert.equal(newASTNode.getLocation(), field);
});
test('navigateBetweenStacks_Forward', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.NEXT, this.blocks.statementInput1.nextConnection);
var newASTNode = node.navigateBetweenStacks_(true);
assertEquals(newASTNode.getLocation(), this.blocks.statementInput4);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
});
test('navigateBetweenStacks_Backward', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var newASTNode = node.navigateBetweenStacks_(false);
assertEquals(newASTNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
});
test('getOutAstNodeForBlock_', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput2);
var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput2);
assertEquals(newASTNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
});
test('getOutAstNodeForBlock_OneBlock', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput4);
assertEquals(newASTNode.getLocation(), this.blocks.statementInput4);
chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
});
test('findFirstFieldOrInput_', function() {
var node = new Blockly.ASTNode(
Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
var field = this.blocks.statementInput4.inputList[0].fieldRow[0];
var newASTNode = node.findFirstFieldOrInput_(this.blocks.statementInput4);
assertEquals(newASTNode.getLocation(), field);
chai.assert.equal(newASTNode.getLocation(), field);
});
});
@@ -345,95 +345,95 @@ suite('ASTNode', function() {
var prevConnection = this.blocks.statementInput1.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput1);
});
test('fromBlockToNext', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), nextConnection);
chai.assert.equal(nextNode.getLocation(), nextConnection);
});
test('fromBlockToNull', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.noNextConnection);
var nextNode = node.next();
assertEquals(nextNode, null);
chai.assert.isNull(nextNode);
});
test('fromNextToPrevious', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var prevConnection = this.blocks.statementInput2.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), prevConnection);
chai.assert.equal(nextNode.getLocation(), prevConnection);
});
test('fromNextToNull', function() {
var nextConnection = this.blocks.statementInput2.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var nextNode = node.next();
assertEquals(nextNode, null);
chai.assert.isNull(nextNode);
});
test('fromInputToInput', function() {
var input = this.blocks.statementInput1.inputList[0];
var inputConnection = this.blocks.statementInput1.inputList[1].connection;
var node = Blockly.ASTNode.createInputNode(input);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), inputConnection);
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromInputToStatementInput', function() {
var input = this.blocks.fieldAndInputs2.inputList[1];
var inputConnection = this.blocks.fieldAndInputs2.inputList[2].connection;
var node = Blockly.ASTNode.createInputNode(input);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), inputConnection);
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromInputToField', function() {
var input = this.blocks.fieldAndInputs2.inputList[0];
var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
var node = Blockly.ASTNode.createInputNode(input);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), field);
chai.assert.equal(nextNode.getLocation(), field);
});
test('fromInputToNull', function() {
var input = this.blocks.fieldAndInputs2.inputList[2];
var node = Blockly.ASTNode.createInputNode(input);
var nextNode = node.next();
assertEquals(nextNode, null);
chai.assert.isNull(nextNode);
});
test('fromOutputToBlock', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), this.blocks.fieldWithOutput);
chai.assert.equal(nextNode.getLocation(), this.blocks.fieldWithOutput);
});
test('fromFieldToInput', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[1];
var inputConnection = this.blocks.statementInput1.inputList[0].connection;
var node = Blockly.ASTNode.createFieldNode(field);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), inputConnection);
chai.assert.equal(nextNode.getLocation(), inputConnection);
});
test('fromFieldToField', function() {
var field = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var field2 = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
var nextNode = node.next();
assertEquals(nextNode.getLocation(), field2);
chai.assert.equal(nextNode.getLocation(), field2);
});
test('fromFieldToNull', function() {
var field = this.blocks.twoFields.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var nextNode = node.next();
assertEquals(nextNode, null);
chai.assert.isNull(nextNode);
});
test('fromStackToStack', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
var nextNode = node.next();
assertEquals(nextNode.getLocation(), this.blocks.statementInput4);
assertEquals(nextNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput4);
chai.assert.equal(nextNode.getType(), Blockly.ASTNode.types.STACK);
});
test('fromStackToNull', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.singleBlock);
var nextNode = node.next();
assertEquals(nextNode, null);
chai.assert.isNull(nextNode);
});
});
@@ -442,94 +442,94 @@ suite('ASTNode', function() {
var prevConnection = this.blocks.statementInput1.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromPreviousToNext', function() {
var prevConnection = this.blocks.statementInput2.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
var nextConnection = this.blocks.statementInput1.nextConnection;
assertEquals(prevNode.getLocation(), nextConnection);
chai.assert.equal(prevNode.getLocation(), nextConnection);
});
test('fromPreviousToInput', function() {
var prevConnection = this.blocks.statementInput3.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromBlockToPrevious', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var prevNode = node.prev();
var prevConnection = this.blocks.statementInput1.previousConnection;
assertEquals(prevNode.getLocation(), prevConnection);
chai.assert.equal(prevNode.getLocation(), prevConnection);
});
test('fromBlockToNull', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.noPrevConnection);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromBlockToOutput', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.fieldWithOutput);
var prevNode = node.prev();
var outputConnection = this.blocks.fieldWithOutput.outputConnection;
assertEquals(prevNode.getLocation(), outputConnection);
chai.assert.equal(prevNode.getLocation(), outputConnection);
});
test('fromNextToBlock', function() {
var nextConnection = this.blocks.statementInput1.nextConnection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
});
test('fromInputToField', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), input.fieldRow[1]);
chai.assert.equal(prevNode.getLocation(), input.fieldRow[1]);
});
test('fromInputToNull', function() {
var input = this.blocks.fieldAndInputs2.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromInputToInput', function() {
var input = this.blocks.fieldAndInputs2.inputList[2];
var inputConnection = this.blocks.fieldAndInputs2.inputList[1].connection;
var node = Blockly.ASTNode.createInputNode(input);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), inputConnection);
chai.assert.equal(prevNode.getLocation(), inputConnection);
});
test('fromOutputToNull', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromFieldToNull', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var prevNode = node.prev();
assertEquals(prevNode, null);
chai.assert.isNull(prevNode);
});
test('fromFieldToInput', function() {
var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
var inputConnection = this.blocks.fieldAndInputs2.inputList[0].connection;
var node = Blockly.ASTNode.createFieldNode(field);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), inputConnection);
chai.assert.equal(prevNode.getLocation(), inputConnection);
});
test('fromFieldToField', function() {
var field = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
var field2 = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), field2);
chai.assert.equal(prevNode.getLocation(), field2);
});
test('fromStackToStack', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
var prevNode = node.prev();
assertEquals(prevNode.getLocation(), this.blocks.statementInput1);
assertEquals(prevNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
chai.assert.equal(prevNode.getType(), Blockly.ASTNode.types.STACK);
});
});
@@ -546,96 +546,96 @@ suite('ASTNode', function() {
var node = Blockly.ASTNode.createInputNode(input);
var inNode = node.in();
var outputConnection = this.blocks.fieldWithOutput.outputConnection;
assertEquals(inNode.getLocation(), outputConnection);
chai.assert.equal(inNode.getLocation(), outputConnection);
});
test('fromInputToNull', function() {
var input = this.blocks.statementInput2.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
var inNode = node.in();
assertEquals(inNode, null);
chai.assert.isNull(inNode);
});
test('fromInputToPrevious', function() {
var input = this.blocks.statementInput2.inputList[1];
var previousConnection = this.blocks.statementInput3.previousConnection;
var node = Blockly.ASTNode.createInputNode(input);
var inNode = node.in();
assertEquals(inNode.getLocation(), previousConnection);
chai.assert.equal(inNode.getLocation(), previousConnection);
});
test('fromBlockToInput', function() {
var input = this.blocks.valueInput.inputList[0];
var node = Blockly.ASTNode.createBlockNode(this.blocks.valueInput);
var inNode = node.in();
assertEquals(inNode.getLocation(), input.connection);
chai.assert.equal(inNode.getLocation(), input.connection);
});
test('fromBlockToField', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
var inNode = node.in();
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
assertEquals(inNode.getLocation(), field);
chai.assert.equal(inNode.getLocation(), field);
});
test('fromBlockToPrevious', function() {
var prevConnection = this.blocks.statementInput4.previousConnection;
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
var inNode = node.in();
assertEquals(inNode.getLocation(), prevConnection);
assertEquals(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.equal(inNode.getLocation(), prevConnection);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
});
test('fromBlockToNull_DummyInput', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInput);
var inNode = node.in();
assertEquals(inNode, null);
chai.assert.isNull(inNode);
});
test('fromBlockToInput_DummyInputValue', function() {
var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInputValue);
var inputConnection = this.blocks.dummyInputValue.inputList[1].connection;
var inNode = node.in();
assertEquals(inNode.getLocation(), inputConnection);
chai.assert.equal(inNode.getLocation(), inputConnection);
});
test('fromOuputToNull', function() {
var output = this.blocks.fieldWithOutput.outputConnection;
var node = Blockly.ASTNode.createConnectionNode(output);
var inNode = node.in();
assertEquals(inNode, null);
chai.assert.isNull(inNode);
});
test('fromFieldToNull', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
var inNode = node.in();
assertEquals(inNode, null);
chai.assert.isNull(inNode);
});
test('fromWorkspaceToStack', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode.createWorkspaceNode(this.workspace, coordinate);
var inNode = node.in();
assertEquals(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
assertEquals(inNode.getType(), Blockly.ASTNode.types.STACK);
chai.assert.equal(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.STACK);
});
test('fromWorkspaceToNull', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode.createWorkspaceNode(
this.emptyWorkspace, coordinate);
var inNode = node.in();
assertEquals(inNode, null);
chai.assert.isNull(inNode);
});
test('fromStackToPrevious', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
var previous = this.blocks.statementInput1.previousConnection;
var inNode = node.in();
assertEquals(inNode.getLocation(), previous);
assertEquals(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.equal(inNode.getLocation(), previous);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
});
test('fromStackToOutput', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.fieldWithOutput2);
var output = this.blocks.fieldWithOutput2.outputConnection;
var inNode = node.in();
assertEquals(inNode.getLocation(), output);
assertEquals(inNode.getType(), Blockly.ASTNode.types.OUTPUT);
chai.assert.equal(inNode.getLocation(), output);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.OUTPUT);
});
test('fromStackToBlock', function() {
var node = Blockly.ASTNode.createStackNode(this.blocks.dummyInput);
var inNode = node.in();
assertEquals(inNode.getLocation(), this.blocks.dummyInput);
assertEquals(inNode.getType(), Blockly.ASTNode.types.BLOCK);
chai.assert.equal(inNode.getLocation(), this.blocks.dummyInput);
chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.BLOCK);
});
});
@@ -774,55 +774,55 @@ suite('ASTNode', function() {
test('createFieldNode', function() {
var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
var node = Blockly.ASTNode.createFieldNode(field);
assertEquals(node.getLocation(), field);
assertEquals(node.getType(), Blockly.ASTNode.types.FIELD);
assertFalse(node.isConnection());
chai.assert.equal(node.getLocation(), field);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.FIELD);
chai.assert.isFalse(node.isConnection());
});
test('createConnectionNode', function() {
var prevConnection = this.blocks.statementInput4.previousConnection;
var node = Blockly.ASTNode.createConnectionNode(prevConnection);
assertEquals(node.getLocation(), prevConnection);
assertEquals(node.getType(), Blockly.ASTNode.types.PREVIOUS);
assertTrue(node.isConnection());
chai.assert.equal(node.getLocation(), prevConnection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.PREVIOUS);
chai.assert.isTrue(node.isConnection());
});
test('createInputNode', function() {
var input = this.blocks.statementInput1.inputList[0];
var node = Blockly.ASTNode.createInputNode(input);
assertEquals(node.getLocation(), input.connection);
assertEquals(node.getType(), Blockly.ASTNode.types.INPUT);
assertTrue(node.isConnection());
chai.assert.equal(node.getLocation(), input.connection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.isTrue(node.isConnection());
});
test('createWorkspaceNode', function() {
var coordinate = new Blockly.utils.Coordinate(100, 100);
var node = Blockly.ASTNode
.createWorkspaceNode(this.workspace, coordinate);
assertEquals(node.getLocation(), this.workspace);
assertEquals(node.getType(), Blockly.ASTNode.types.WORKSPACE);
assertEquals(node.getWsCoordinate(), coordinate);
assertFalse(node.isConnection());
chai.assert.equal(node.getLocation(), this.workspace);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.WORKSPACE);
chai.assert.equal(node.getWsCoordinate(), coordinate);
chai.assert.isFalse(node.isConnection());
});
test('createStatementConnectionNode', function() {
var nextConnection = this.blocks.statementInput1.inputList[1].connection;
var inputConnection = this.blocks.statementInput1.inputList[1].connection;
var node = Blockly.ASTNode.createConnectionNode(nextConnection);
assertEquals(node.getLocation(), inputConnection);
assertEquals(node.getType(), Blockly.ASTNode.types.INPUT);
assertTrue(node.isConnection());
chai.assert.equal(node.getLocation(), inputConnection);
chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
chai.assert.isTrue(node.isConnection());
});
test('createTopNode-previous', function() {
var block = this.blocks.statementInput1;
var topNode = Blockly.ASTNode.createTopNode(block);
assertEquals(topNode.getLocation(), block.previousConnection);
chai.assert.equal(topNode.getLocation(), block.previousConnection);
});
test('createTopNode-block', function() {
var block = this.blocks.noPrevConnection;
var topNode = Blockly.ASTNode.createTopNode(block);
assertEquals(topNode.getLocation(), block);
chai.assert.equal(topNode.getLocation(), block);
});
test('createTopNode-output', function() {
var block = this.blocks.outputNextBlock;
var topNode = Blockly.ASTNode.createTopNode(block);
assertEquals(topNode.getLocation(), block.outputConnection);
chai.assert.equal(topNode.getLocation(), block.outputConnection);
});
});
});

78
tests/mocha/block_test.js
View File

@@ -63,7 +63,7 @@ suite('Blocks', function() {
blockB.nextConnection.connect(blockC.previousConnection);
}
assertEquals(blockB, blockC.getParent());
chai.assert.equal(blockC.getParent(), blockB);
return {
A: blockA, /* Parent */
@@ -75,30 +75,30 @@ suite('Blocks', function() {
suite('Unplug', function() {
function assertUnpluggedNoheal(blocks) {
// A has nothing connected to it.
assertEquals(0, blocks.A.getChildren().length);
chai.assert.equal(blocks.A.getChildren().length, 0);
// B and C are still connected.
assertEquals(blocks.B, blocks.C.getParent());
chai.assert.equal(blocks.C.getParent(), blocks.B);
// B is the top of its stack.
assertNull(blocks.B.getParent());
chai.assert.isNull(blocks.B.getParent());
}
function assertUnpluggedHealed(blocks) {
// A and C are connected.
assertEquals(1, blocks.A.getChildren().length);
assertEquals(blocks.A, blocks.C.getParent());
chai.assert.equal(blocks.A.getChildren().length, 1);
chai.assert.equal(blocks.C.getParent(), blocks.A);
// B has nothing connected to it.
assertEquals(0, blocks.B.getChildren().length);
chai.assert.equal(blocks.B.getChildren().length, 0);
// B is the top of its stack.
assertNull(blocks.B.getParent());
chai.assert.isNull(blocks.B.getParent());
}
function assertUnpluggedHealFailed(blocks) {
// A has nothing connected to it.
assertEquals(0, blocks.A.getChildren().length);
chai.assert.equal(blocks.A.getChildren().length, 0);
// B has nothing connected to it.
assertEquals(0, blocks.B.getChildren().length);
chai.assert.equal(blocks.B.getChildren().length, 0);
// B is the top of its stack.
assertNull(blocks.B.getParent());
chai.assert.isNull(blocks.B.getParent());
// C is the top of its stack.
assertNull(blocks.C.getParent());
chai.assert.isNull(blocks.C.getParent());
}
suite('Row', function() {
@@ -195,7 +195,7 @@ suite('Blocks', function() {
function assertDisposedNoheal(blocks) {
chai.assert.isFalse(blocks.A.disposed);
// A has nothing connected to it.
chai.assert.equal(0, blocks.A.getChildren().length);
chai.assert.equal(blocks.A.getChildren().length, 0);
// B is disposed.
chai.assert.isTrue(blocks.B.disposed);
// And C is disposed.
@@ -205,8 +205,8 @@ suite('Blocks', function() {
chai.assert.isFalse(blocks.A.disposed);
chai.assert.isFalse(blocks.C.disposed);
// A and C are connected.
assertEquals(1, blocks.A.getChildren().length);
assertEquals(blocks.A, blocks.C.getParent());
chai.assert.equal(blocks.A.getChildren().length, 1);
chai.assert.equal(blocks.C.getParent(), blocks.A);
// B is disposed.
chai.assert.isTrue(blocks.B.disposed);
}
@@ -214,11 +214,11 @@ suite('Blocks', function() {
chai.assert.isFalse(blocks.A.disposed);
chai.assert.isFalse(blocks.C.disposed);
// A has nothing connected to it.
chai.assert.equal(0, blocks.A.getChildren().length);
chai.assert.equal(blocks.A.getChildren().length, 0);
// B is disposed.
chai.assert.isTrue(blocks.B.disposed);
// C is the top of its stack.
assertNull(blocks.C.getParent());
chai.assert.isNull(blocks.C.getParent());
}
suite('Row', function() {
@@ -1075,14 +1075,14 @@ suite('Blocks', function() {
});
test('Text Null', function() {
this.block.setCommentText(null);
chai.assert.equal(this.block.getCommentText(), null);
chai.assert.isNull(this.block.getCommentText());
assertNoCommentEvent(this.eventSpy);
});
test('Text -> Null', function() {
this.block.setCommentText('first text');
this.block.setCommentText(null);
chai.assert.equal(this.block.getCommentText(), null);
chai.assert.isNull(this.block.getCommentText());
assertCommentEvent(this.eventSpy, 'first text', null);
});
});
@@ -1111,14 +1111,14 @@ suite('Blocks', function() {
});
test('Text Null', function() {
this.block.setCommentText(null);
chai.assert.equal(this.block.getCommentText(), null);
chai.assert.isNull(this.block.getCommentText());
assertNoCommentEvent(this.eventSpy);
});
test('Text -> Null', function() {
this.block.setCommentText('first text');
this.block.setCommentText(null);
chai.assert.equal(this.block.getCommentText(), null);
chai.assert.isNull(this.block.getCommentText());
assertCommentEvent(this.eventSpy, 'first text', null);
});
test('Set While Visible - Editable', function() {
@@ -1558,7 +1558,7 @@ suite('Blocks', function() {
assertCollapsed(blockA);
var field = blockA.getField('FIELD');
chai.assert.isNotNull(field);
chai.assert.equal('test', field.getText());
chai.assert.equal(field.getText(), 'test');
});
test('Add Icon', function() {
var blockA = this.createBlock('empty_block');
@@ -1646,16 +1646,16 @@ suite('Blocks', function() {
});
test('Set colour', function() {
this.block.setColour('20');
assertEquals(this.block.getColour(), '#a5745b');
assertEquals(this.block.colour_, this.block.getColour());
assertEquals(this.block.hue_, '20');
chai.assert.equal(this.block.getColour(), '#a5745b');
chai.assert.equal(this.block.colour_, this.block.getColour());
chai.assert.equal(this.block.hue_, '20');
});
test('Set style', function() {
this.block.setStyle('styleOne');
assertEquals(this.block.getStyleName(), 'styleOne');
assertEquals(this.block.hue_, null);
chai.assert.equal(this.block.getStyleName(), 'styleOne');
chai.assert.isNull(this.block.hue_);
// Calling setStyle does not update the colour on a headless block.
assertEquals(this.block.getColour(), '#000000');
chai.assert.equal(this.block.getColour(), '#000000');
});
});
suite('Rendered', function() {
@@ -1678,23 +1678,23 @@ suite('Blocks', function() {
});
test('Set colour hue', function() {
this.block.setColour('20');
assertEquals(this.block.getStyleName(), 'auto_#a5745b');
assertEquals(this.block.getColour(), '#a5745b');
assertEquals(this.block.colour_, this.block.getColour());
assertEquals(this.block.hue_, '20');
chai.assert.equal(this.block.getStyleName(), 'auto_#a5745b');
chai.assert.equal(this.block.getColour(), '#a5745b');
chai.assert.equal(this.block.colour_, this.block.getColour());
chai.assert.equal(this.block.hue_, '20');
});
test('Set colour hex', function() {
this.block.setColour('#000000');
assertEquals(this.block.getStyleName(), 'auto_#000000');
assertEquals(this.block.getColour(), '#000000');
assertEquals(this.block.colour_, this.block.getColour());
assertEquals(this.block.hue_, null);
chai.assert.equal(this.block.getStyleName(), 'auto_#000000');
chai.assert.equal(this.block.getColour(), '#000000');
chai.assert.equal(this.block.colour_, this.block.getColour());
chai.assert.isNull(this.block.hue_);
});
test('Set style', function() {
this.block.setStyle('styleOne');
assertEquals(this.block.getStyleName(), 'styleOne');
assertEquals(this.block.getColour(), '#000000');
assertEquals(this.block.colour_, this.block.getColour());
chai.assert.equal(this.block.getStyleName(), 'styleOne');
chai.assert.equal(this.block.getColour(), '#000000');
chai.assert.equal(this.block.colour_, this.block.getColour());
});
});
});

10
tests/mocha/cursor_test.js
View File

@@ -83,14 +83,14 @@ suite('Cursor', function() {
this.cursor.setCurNode(prevNode);
this.cursor.next();
var curNode = this.cursor.getCurNode();
assertEquals(curNode.getLocation(), this.blocks.B.previousConnection);
chai.assert.equal(curNode.getLocation(), this.blocks.B.previousConnection);
});
test('Next - From last block in a stack go to next connection', function() {
var prevNode = Blockly.ASTNode.createConnectionNode(this.blocks.B.previousConnection);
this.cursor.setCurNode(prevNode);
this.cursor.next();
var curNode = this.cursor.getCurNode();
assertEquals(curNode.getLocation(), this.blocks.B.nextConnection);
chai.assert.equal(curNode.getLocation(), this.blocks.B.nextConnection);
});
test('In - From output connection', function() {
@@ -99,7 +99,7 @@ suite('Cursor', function() {
this.cursor.setCurNode(outputNode);
this.cursor.in();
var curNode = this.cursor.getCurNode();
assertEquals(curNode.getLocation(), fieldBlock.inputList[0].fieldRow[0]);
chai.assert.equal(curNode.getLocation(), fieldBlock.inputList[0].fieldRow[0]);
});
test('Prev - From previous connection skip over next connection', function() {
@@ -108,7 +108,7 @@ suite('Cursor', function() {
this.cursor.setCurNode(prevConnectionNode);
this.cursor.prev();
var curNode = this.cursor.getCurNode();
assertEquals(curNode.getLocation(), this.blocks.A.previousConnection);
chai.assert.equal(curNode.getLocation(), this.blocks.A.previousConnection);
});
test('Out - From field skip over block node', function() {
@@ -117,6 +117,6 @@ suite('Cursor', function() {
this.cursor.setCurNode(fieldNode);
this.cursor.out();
var curNode = this.cursor.getCurNode();
assertEquals(curNode.getLocation(), this.blocks.E.outputConnection);
chai.assert.equal(curNode.getLocation(), this.blocks.E.outputConnection);
});
});

167
tests/mocha/event_test.js
View File

@@ -38,24 +38,24 @@ suite('Events', function() {
var keys = Object.keys(values);
for (var i = 0; i < keys.length; i++) {
var field = keys[i];
assertEquals(values[field], event[field]);
chai.assert.equal(values[field], event[field]);
}
}
function checkCreateEventValues(event, block, ids, type) {
var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
var result_xml = Blockly.Xml.domToText(event.xml);
assertEquals(expected_xml, result_xml);
isEqualArrays(ids, event.ids);
assertEquals(type, event.type);
chai.assert.equal(expected_xml, result_xml);
assertArrayEquals(ids, event.ids);
chai.assert.equal(type, event.type);
}
function checkDeleteEventValues(event, block, ids, type) {
var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
var result_xml = Blockly.Xml.domToText(event.oldXml);
assertEquals(expected_xml, result_xml);
isEqualArrays(ids, event.ids);
assertEquals(type, event.type);
chai.assert.equal(expected_xml, result_xml);
assertArrayEquals(ids, event.ids);
chai.assert.equal(type, event.type);
}
function createSimpleTestBlock(workspace, opt_prototypeName) {
@@ -71,9 +71,9 @@ suite('Events', function() {
suite('Constructors', function() {
test('Abstract', function() {
var event = new Blockly.Events.Abstract();
assertUndefined(event.blockId);
assertUndefined(event.workspaceId);
assertUndefined(event.varId);
chai.assert.isUndefined(event.blockId);
chai.assert.isUndefined(event.workspaceId);
chai.assert.isUndefined(event.varId);
checkExactEventValues(event, {'group': '', 'recordUndo': true});
});
@@ -106,7 +106,7 @@ suite('Events', function() {
test('Block base', function() {
var event = new Blockly.Events.BlockBase(this.block);
assertUndefined(event.varId);
chai.assert.isUndefined(event.varId);
checkExactEventValues(event,
{
'blockId': this.FAKE_ID,
@@ -228,10 +228,26 @@ suite('Events', function() {
this.variable = this.workspace.createVariable('name1', 'type1', 'id1');
});
/**
* Check if a variable with the given values exists.
* @param {Blockly.Workspace|Blockly.VariableMap} container The workspace or
* variableMap the checked variable belongs to.
* @param {!string} name The expected name of the variable.
* @param {!string} type The expected type of the variable.
* @param {!string} id The expected id of the variable.
*/
function checkVariableValues(container, name, type, id) {
var variable = container.getVariableById(id);
chai.assert.isDefined(variable);
chai.assert.equal(name, variable.name);
chai.assert.equal(type, variable.type);
chai.assert.equal(id, variable.getId());
}
suite('Constructors', function() {
test('Var base', function() {
var event = new Blockly.Events.VarBase(this.variable);
assertUndefined(event.blockId);
chai.assert.isUndefined(event.blockId);
checkExactEventValues(event, {'varId': 'id1',
'workspaceId': this.workspace.id, 'group': '', 'recordUndo': true});
});
@@ -262,7 +278,7 @@ suite('Events', function() {
var json = event.toJson();
event2.fromJson(json);
assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
});
test('Var delete', function() {
var event = new Blockly.Events.VarDelete(this.variable);
@@ -270,7 +286,7 @@ suite('Events', function() {
var json = event.toJson();
event2.fromJson(json);
assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
});
test('Var rename', function() {
var event = new Blockly.Events.VarRename(this.variable, '');
@@ -278,7 +294,7 @@ suite('Events', function() {
var json = event.toJson();
event2.fromJson(json);
assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
});
});
@@ -289,7 +305,7 @@ suite('Events', function() {
var expectedJson = ({type: "var_create", varId: "id1", varType: "type1",
varName: "name1"});
assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
});
test('Var delete', function() {
@@ -298,7 +314,7 @@ suite('Events', function() {
var expectedJson = ({type: "var_delete", varId: "id1", varType: "type1",
varName: "name1"});
assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
});
test('Var rename', function() {
@@ -307,7 +323,7 @@ suite('Events', function() {
var expectedJson = ({type: "var_rename", varId: "id1", oldName: "name1",
newName: "name2"});
assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
});
});
@@ -317,29 +333,29 @@ suite('Events', function() {
varName: "name2"};
var event = Blockly.Events.fromJson(json, this.workspace);
var x = this.workspace.getVariableById('id2');
assertNull(x);
chai.assert.isNull(x);
event.run(true);
assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
});
test('Var delete', function() {
var event = new Blockly.Events.VarDelete(this.variable);
assertNotNull(this.workspace.getVariableById('id1'));
chai.assert.isNotNull(this.workspace.getVariableById('id1'));
event.run(true);
assertNull(this.workspace.getVariableById('id1'));
chai.assert.isNull(this.workspace.getVariableById('id1'));
});
test('Var rename', function() {
var event = new Blockly.Events.VarRename(this.variable, 'name2');
event.run(true);
assertNull(this.workspace.getVariable('name1'));
assertVariableValues(this.workspace, 'name2', 'type1', 'id1');
chai.assert.isNull(this.workspace.getVariable('name1'));
checkVariableValues(this.workspace, 'name2', 'type1', 'id1');
});
});
suite('Run Backward', function() {
test('Var create', function() {
var event = new Blockly.Events.VarCreate(this.variable);
assertNotNull(this.workspace.getVariableById('id1'));
chai.assert.isNotNull(this.workspace.getVariableById('id1'));
event.run(false);
});
@@ -347,7 +363,7 @@ suite('Events', function() {
var json = {type: "var_delete", varId: "id2", varType: "type2",
varName: "name2"};
var event = Blockly.Events.fromJson(json, this.workspace);
assertNull(this.workspace.getVariableById('id2'));
chai.assert.isNull(this.workspace.getVariableById('id2'));
event.run(false);
assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
});
@@ -355,8 +371,8 @@ suite('Events', function() {
test('Var rename', function() {
var event = new Blockly.Events.VarRename(this.variable, 'name2');
event.run(false);
assertNull(this.workspace.getVariable('name2'));
assertVariableValues(this.workspace, 'name1', 'type1', 'id1');
chai.assert.isNull(this.workspace.getVariable('name2'));
checkVariableValues(this.workspace, 'name1', 'type1', 'id1');
});
});
});
@@ -384,12 +400,12 @@ suite('Events', function() {
new Blockly.Events.Ui(block, 'click', undefined, undefined)
];
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(4, filteredEvents.length); // no event should have been removed.
chai.assert.equal(4, filteredEvents.length); // no event should have been removed.
// test that the order hasn't changed
assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
assertTrue(filteredEvents[2] instanceof Blockly.Events.BlockChange);
assertTrue(filteredEvents[3] instanceof Blockly.Events.Ui);
chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
chai.assert.isTrue(filteredEvents[2] instanceof Blockly.Events.BlockChange);
chai.assert.isTrue(filteredEvents[3] instanceof Blockly.Events.Ui);
});
test('Different blocks no removed', function() {
@@ -402,7 +418,7 @@ suite('Events', function() {
new Blockly.Events.BlockMove(block2)
];
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(4, filteredEvents.length); // no event should have been removed.
chai.assert.equal(4, filteredEvents.length); // no event should have been removed.
});
test('Forward', function() {
@@ -412,12 +428,12 @@ suite('Events', function() {
addMoveEvent(events, block, 2, 2);
addMoveEvent(events, block, 3, 3);
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(2, filteredEvents.length); // duplicate moves should have been removed.
chai.assert.equal(2, filteredEvents.length); // duplicate moves should have been removed.
// test that the order hasn't changed
assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
assertEquals(3, filteredEvents[1].newCoordinate.x);
assertEquals(3, filteredEvents[1].newCoordinate.y);
chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
chai.assert.equal(3, filteredEvents[1].newCoordinate.x);
chai.assert.equal(3, filteredEvents[1].newCoordinate.y);
});
test('Backward', function() {
@@ -427,12 +443,12 @@ suite('Events', function() {
addMoveEvent(events, block, 2, 2);
addMoveEvent(events, block, 3, 3);
var filteredEvents = Blockly.Events.filter(events, false);
assertEquals(2, filteredEvents.length); // duplicate event should have been removed.
chai.assert.equal(2, filteredEvents.length); // duplicate event should have been removed.
// test that the order hasn't changed
assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
assertEquals(1, filteredEvents[1].newCoordinate.x);
assertEquals(1, filteredEvents[1].newCoordinate.y);
chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
chai.assert.equal(1, filteredEvents[1].newCoordinate.x);
chai.assert.equal(1, filteredEvents[1].newCoordinate.y);
});
test('Merge move events', function() {
@@ -441,9 +457,9 @@ suite('Events', function() {
addMoveEvent(events, block, 0, 0);
addMoveEvent(events, block, 1, 1);
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(1, filteredEvents.length); // second move event merged into first
assertEquals(1, filteredEvents[0].newCoordinate.x);
assertEquals(1, filteredEvents[0].newCoordinate.y);
chai.assert.equal(1, filteredEvents.length); // second move event merged into first
chai.assert.equal(1, filteredEvents[0].newCoordinate.x);
chai.assert.equal(1, filteredEvents[0].newCoordinate.y);
});
test('Merge change events', function() {
@@ -453,9 +469,9 @@ suite('Events', function() {
new Blockly.Events.Change(block1, 'field', 'VAR', 'item1', 'item2')
];
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(1, filteredEvents.length); // second change event merged into first
assertEquals('item', filteredEvents[0].oldValue);
assertEquals('item2', filteredEvents[0].newValue);
chai.assert.equal(1, filteredEvents.length); // second change event merged into first
chai.assert.equal(filteredEvents[0].oldValue, 'item');
chai.assert.equal(filteredEvents[0].newValue, 'item2');
});
test('Merge ui events', function() {
@@ -471,10 +487,11 @@ suite('Events', function() {
new Blockly.Events.Ui(block3, 'click', 'false', 'true')
];
var filteredEvents = Blockly.Events.filter(events, true);
assertEquals(3, filteredEvents.length); // click event merged into corresponding *Open event
assertEquals('commentOpen', filteredEvents[0].element);
assertEquals('mutatorOpen', filteredEvents[1].element);
assertEquals('warningOpen', filteredEvents[2].element);
// click event merged into corresponding *Open event
chai.assert.equal(filteredEvents.length, 3);
chai.assert.equal(filteredEvents[0].element, 'commentOpen');
chai.assert.equal(filteredEvents[1].element, 'mutatorOpen');
chai.assert.equal(filteredEvents[2].element, 'warningOpen');
});
test('Colliding events not dropped', function() {
@@ -487,9 +504,9 @@ suite('Events', function() {
];
var filteredEvents = Blockly.Events.filter(events, true);
// click and stackclick should both exist
assertEquals(2, filteredEvents.length);
assertEquals('click', filteredEvents[0].element);
assertEquals('stackclick', filteredEvents[1].element);
chai.assert.equal(2, filteredEvents.length);
chai.assert.equal(filteredEvents[0].element, 'click');
chai.assert.equal(filteredEvents[1].element, 'stackclick');
});
test('Merging null operations dropped', function() {
@@ -508,7 +525,7 @@ suite('Events', function() {
var filteredEvents = Blockly.Events.filter(events, true);
// The two events should be merged, but because nothing has changed
// they will be filtered out.
assertEquals(0, filteredEvents.length);
chai.assert.equal(0, filteredEvents.length);
});
test('Move events different blocks not merged', function() {
@@ -528,12 +545,12 @@ suite('Events', function() {
var filteredEvents = Blockly.Events.filter(events, true);
// Nothing should have merged.
assertEquals(4, filteredEvents.length);
chai.assert.equal(4, filteredEvents.length);
// test that the order hasn't changed
assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockMove);
assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
assertTrue(filteredEvents[2] instanceof Blockly.Events.BlockDelete);
assertTrue(filteredEvents[3] instanceof Blockly.Events.BlockMove);
chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockMove);
chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
chai.assert.isTrue(filteredEvents[2] instanceof Blockly.Events.BlockDelete);
chai.assert.isTrue(filteredEvents[3] instanceof Blockly.Events.BlockMove);
});
});
@@ -568,22 +585,22 @@ suite('Events', function() {
var firedEvents = this.workspace.undoStack_;
// Expect two events: varCreate and block create.
assertEquals(2, firedEvents.length);
chai.assert.equal(2, firedEvents.length);
var event0 = firedEvents[0];
var event1 = firedEvents[1];
assertEquals('var_create', event0.type);
assertEquals('create', event1.type);
chai.assert.equal(event0.type, 'var_create');
chai.assert.equal(event1.type, 'create');
// Expect the events to have the same group ID.
assertEquals(event0.group, event1.group);
chai.assert.equal(event0.group, event1.group);
// Expect the group ID to be the result of the second call to genUid.
assertEquals('2', event0.group);
chai.assert.equal(event0.group, '2');
// Expect the workspace to have a variable with ID '3'.
assertNotNull(this.workspace.getVariableById('3'));
assertEquals('3', event0.varId);
chai.assert.isNotNull(this.workspace.getVariableById('3'));
chai.assert.equal(event0.varId, '3');
});
test('New block new var xml', function() {
@@ -599,19 +616,19 @@ suite('Events', function() {
var firedEvents = this.workspace.undoStack_;
// Expect two events: varCreate and block create.
assertEquals(2, firedEvents.length);
chai.assert.equal(2, firedEvents.length);
var event0 = firedEvents[0];
var event1 = firedEvents[1];
assertEquals('var_create', event0.type);
assertEquals('create', event1.type);
chai.assert.equal(event0.type, 'var_create');
chai.assert.equal(event1.type, 'create');
// Expect the events to have the same group ID.
assertEquals(event0.group, event1.group);
chai.assert.equal(event0.group, event1.group);
// Expect the workspace to have a variable with ID 'id1'.
assertNotNull(this.workspace.getVariableById('id1'));
assertEquals('id1', event0.varId);
chai.assert.isNotNull(this.workspace.getVariableById('id1'));
chai.assert.equal(event0.varId, 'id1');
});
});
});

82
tests/mocha/extensions_test.js
View File

@@ -32,7 +32,7 @@ suite('Extensions', function() {
this.extensionsCleanup_.push('extensions_test_after');
this.blockTypesCleanup_.push('extension_test_block');
assertUndefined(Blockly.Extensions.ALL_['extensions_test_before']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test_before']);
var beforeCallback = sinon.spy();
// Extension defined before the block type is defined.
Blockly.Extensions.register('extensions_test_before', beforeCallback);
@@ -43,13 +43,13 @@ suite('Extensions', function() {
"extensions": ["extensions_test_before", "extensions_test_after"]
}]);
assertUndefined(Blockly.Extensions.ALL_['extensions_test_after']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test_after']);
var afterCallback = sinon.spy();
// Extension defined after the block type (but before instantiation).
Blockly.Extensions.register('extensions_test_after', afterCallback);
assert(typeof Blockly.Extensions.ALL_['extensions_test_before'] == 'function');
assert(typeof Blockly.Extensions.ALL_['extensions_test_after'] == 'function');
chai.assert.typeOf(Blockly.Extensions.ALL_['extensions_test_before'], 'function');
chai.assert.typeOf(Blockly.Extensions.ALL_['extensions_test_after'], 'function');
sinon.assert.notCalled(beforeCallback);
sinon.assert.notCalled(afterCallback);
@@ -92,27 +92,27 @@ suite('Extensions', function() {
new Blockly.Block(this.workspace, 'test_parent_tooltip_when_inline');
// Tooltip is dynamic after extension initialization.
assert(typeof block.tooltip == 'function');
assertEquals(block.tooltip(), defaultTooltip);
chai.assert.typeOf(block.tooltip, 'function');
chai.assert.equal(block.tooltip(), defaultTooltip);
// Tooltip is normal before connected to parent.
var parent = new Blockly.Block(this.workspace, 'test_parent');
assertEquals(parent.tooltip, parentTooltip);
assertFalse(!!parent.inputsInline);
chai.assert.equal(parent.tooltip, parentTooltip);
chai.assert.isFalse(!!parent.inputsInline);
// Tooltip is normal when parent is not inline.
parent.getInput('INPUT').connection.connect(block.outputConnection);
assertEquals(block.getParent(), parent);
assertEquals(block.tooltip(), defaultTooltip);
chai.assert.equal(block.getParent(), parent);
chai.assert.equal(block.tooltip(), defaultTooltip);
// Tooltip is parent's when parent is inline.
parent.setInputsInline(true);
assertEquals(block.tooltip(), parentTooltip);
chai.assert.equal(block.tooltip(), parentTooltip);
// Tooltip revert when disconnected.
parent.getInput('INPUT').connection.disconnect();
assert(!block.getParent());
assertEquals(block.tooltip(), defaultTooltip);
chai.assert.notExists(block.getParent());
chai.assert.equal(block.tooltip(), defaultTooltip);
});
suite('Mixin', function() {
@@ -127,11 +127,11 @@ suite('Extensions', function() {
}
};
assertUndefined(Blockly.Extensions.ALL_['mixin_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_test']);
// Extension defined before the block type is defined.
Blockly.Extensions.registerMixin('mixin_test', testMixin);
assert(typeof Blockly.Extensions.ALL_['mixin_test'] == 'function');
chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_test'], 'function');
Blockly.defineBlocksWithJsonArray([{
"type": "test_block_mixin",
@@ -141,8 +141,8 @@ suite('Extensions', function() {
var block = new Blockly.Block(this.workspace, 'test_block_mixin');
assertEquals(testMixin.field, block.field);
assertEquals(testMixin.method, block.method);
chai.assert.equal(testMixin.field, block.field);
chai.assert.equal(testMixin.method, block.method);
});
suite('Mutator', function() {
@@ -178,10 +178,10 @@ suite('Extensions', function() {
var block = new Blockly.Block(this.workspace, 'mutator_test_block');
// Make sure all of the functions were installed correctly.
assertEquals(block.domToMutation(), 'domToMutationFn');
assertEquals(block.mutationToDom(), 'mutationToDomFn');
assertEquals(block.compose(), 'composeFn');
assertEquals(block.decompose(), 'decomposeFn');
chai.assert.equal(block.domToMutation(), 'domToMutationFn');
chai.assert.equal(block.mutationToDom(), 'mutationToDomFn');
chai.assert.equal(block.compose(), 'composeFn');
chai.assert.equal(block.decompose(), 'decomposeFn');
});
test('With helper function', function() {
@@ -197,7 +197,7 @@ suite('Extensions', function() {
// Events code calls mutationToDom and expects it to give back a
// meaningful value.
Blockly.Events.disable();
assertUndefined(Blockly.Extensions.ALL_['extensions_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test']);
var helperFunctionSpy = sinon.spy();
Blockly.Extensions.registerMutator('extensions_test',
{
@@ -229,7 +229,7 @@ suite('Extensions', function() {
// Events code calls mutationToDom and expects it to give back a
// meaningful value.
Blockly.Events.disable();
assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
Blockly.Extensions.registerMutator('mutator_test',
{
domToMutation: function() {
@@ -243,10 +243,10 @@ suite('Extensions', function() {
var block = new Blockly.Block(this.workspace, 'mutator_test_block');
// Make sure all of the functions were installed correctly.
assertEquals(block.domToMutation(), 'domToMutationFn');
assertEquals(block.mutationToDom(), 'mutationToDomFn');
assertFalse(block.hasOwnProperty('compose'));
assertFalse(block.hasOwnProperty('decompose'));
chai.assert.equal(block.domToMutation(), 'domToMutationFn');
chai.assert.equal(block.mutationToDom(), 'mutationToDomFn');
chai.assert.isFalse(block.hasOwnProperty('compose'));
chai.assert.isFalse(block.hasOwnProperty('decompose'));
});
});
});
@@ -261,7 +261,7 @@ suite('Extensions', function() {
"extensions": ["missing_extension"]
}]);
assertUndefined(Blockly.Extensions.ALL_['missing_extension']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['missing_extension']);
var workspace = this.workspace;
chai.assert.throws(function() {
var _ = new Blockly.Block(workspace, 'missing_extension_block');
@@ -276,10 +276,10 @@ suite('Extensions', function() {
inputList: 'bad inputList' // Defined in constructor
};
assertUndefined(Blockly.Extensions.ALL_['mixin_bad_inputList']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_bad_inputList']);
// Extension defined before the block type is defined.
Blockly.Extensions.registerMixin('mixin_bad_inputList', TEST_MIXIN_BAD_INPUTLIST);
assert(typeof Blockly.Extensions.ALL_['mixin_bad_inputList'] == 'function');
chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_bad_inputList'], 'function');
Blockly.defineBlocksWithJsonArray([{
"type": "test_block_bad_inputList",
@@ -301,10 +301,10 @@ suite('Extensions', function() {
colour_: 'bad colour_' // Defined on prototype
};
assertUndefined(Blockly.Extensions.ALL_['mixin_bad_colour_']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_bad_colour_']);
// Extension defined before the block type is defined.
Blockly.Extensions.registerMixin('mixin_bad_colour_', TEST_MIXIN_BAD_COLOUR);
assert(typeof Blockly.Extensions.ALL_['mixin_bad_colour_'] == 'function');
chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_bad_colour_'], 'function');
Blockly.defineBlocksWithJsonArray([{
"type": "test_block_bad_colour",
@@ -331,7 +331,7 @@ suite('Extensions', function() {
// Events code calls mutationToDom and expects it to give back a
// meaningful value.
Blockly.Events.disable();
assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
Blockly.Extensions.registerMutator('mutator_test',
{
domToMutation: function() {
@@ -347,7 +347,7 @@ suite('Extensions', function() {
var _ = new Blockly.Block(workspace, 'mutator_test_block');
});
// Should have failed on apply, not on register.
assertNotNull(Blockly.Extensions.ALL_['mutator_test']);
chai.assert.isNotNull(Blockly.Extensions.ALL_['mutator_test']);
});
test('Use mutator mixin as extension', function() {
@@ -363,7 +363,7 @@ suite('Extensions', function() {
// Events code calls mutationToDom and expects it to give back a
// meaningful value.
Blockly.Events.disable();
assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
Blockly.Extensions.registerMixin('mutator_test',
{
domToMutation: function() {
@@ -379,7 +379,7 @@ suite('Extensions', function() {
var _ = new Blockly.Block(workspace, 'mutator_test_block');
});
// Should have failed on apply, not on register.
assertNotNull(Blockly.Extensions.ALL_['mutator_test']);
chai.assert.isNotNull(Blockly.Extensions.ALL_['mutator_test']);
});
test('Use extension as mutator', function() {
@@ -395,7 +395,7 @@ suite('Extensions', function() {
// Events code calls mutationToDom and expects it to give back a
// meaningful value.
Blockly.Events.disable();
assertUndefined(Blockly.Extensions.ALL_['extensions_test']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test']);
Blockly.Extensions.register('extensions_test', function() {
return 'extensions_test_fn';
});
@@ -405,13 +405,13 @@ suite('Extensions', function() {
var _ = new Blockly.Block(workspace, 'mutator_test_block');
});
// Should have failed on apply, not on register.
assertNotNull(Blockly.Extensions.ALL_['extensions_test']);
chai.assert.isNotNull(Blockly.Extensions.ALL_['extensions_test']);
});
suite('register', function() {
test('Just a string', function() {
this.extensionsCleanup_.push('extension_just_a_string');
assertUndefined(Blockly.Extensions.ALL_['extension_just_a_string']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_just_a_string']);
chai.assert.throws(function() {
Blockly.Extensions.register('extension_just_a_string', null);
});
@@ -419,7 +419,7 @@ suite('Extensions', function() {
test('Null', function() {
this.extensionsCleanup_.push('extension_is_null');
assertUndefined(Blockly.Extensions.ALL_['extension_is_null']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_is_null']);
chai.assert.throws(function() {
Blockly.Extensions.register('extension_is_null', null);
});
@@ -427,7 +427,7 @@ suite('Extensions', function() {
test('Undefined', function() {
this.extensionsCleanup_.push('extension_is_undefined');
assertUndefined(Blockly.Extensions.ALL_['extension_is_undefined']);
chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_is_undefined']);
chai.assert.throws(function() {
Blockly.Extensions.register('extension_is_undefined', null);
});

6
tests/mocha/field_angle_test.js
View File

@@ -9,9 +9,9 @@ suite('Angle Fields', function() {
var actualValue = angleField.getValue();
var actualText = angleField.getText();
opt_expectedText = opt_expectedText || String(expectedValue);
assertEquals(String(actualValue), String(expectedValue));
assertEquals(Number(actualValue), expectedValue);
assertEquals(actualText, opt_expectedText);
chai.assert.equal(String(actualValue), String(expectedValue));
chai.assert.equal(Number(actualValue), expectedValue);
chai.assert.equal(actualText, opt_expectedText);
}
function assertValueDefault(angleField) {
assertValue(angleField, 0);

4
tests/mocha/field_checkbox_test.js
View File

@@ -8,8 +8,8 @@ suite('Checkbox Fields', function() {
function assertValue(checkboxField, expectedValue, expectedText) {
var actualValue = checkboxField.getValue();
var actualText = checkboxField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedText);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedText);
}
function assertValueDefault(checkboxField) {
assertValue(checkboxField, 'FALSE', 'false');

4
tests/mocha/field_colour_test.js
View File

@@ -8,8 +8,8 @@ suite('Colour Fields', function() {
function assertValue(colourField, expectedValue, expectedText) {
var actualValue = colourField.getValue();
var actualText = colourField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedText);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedText);
}
function assertValueDefault(colourField) {
var expectedValue = Blockly.FieldColour.COLOURS[0];

4
tests/mocha/field_date_test.js
View File

@@ -12,8 +12,8 @@ suite.skip('Date Fields', function() {
function assertValue(dateField, expectedValue) {
var actualValue = dateField.getValue();
var actualText = dateField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedValue);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedValue);
}
function assertValueDefault(dateField) {
var today = new goog.date.Date().toIsoString(true);

4
tests/mocha/field_dropdown_test.js
View File

@@ -8,8 +8,8 @@ suite('Dropdown Fields', function() {
function assertValue(dropdownField, expectedValue, expectedText) {
var actualValue = dropdownField.getValue();
var actualText = dropdownField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedText);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedText);
}
suite('Constructor', function() {
test('Empty', function() {

6
tests/mocha/field_image_test.js
View File

@@ -8,8 +8,8 @@ suite('Image Fields', function() {
function assertValue(imageField, expectedValue, expectedText) {
var actualValue = imageField.getValue();
var actualText = imageField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedText);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedText);
}
suite('Constructor', function() {
test('Empty', function() {
@@ -136,7 +136,7 @@ suite('Image Fields', function() {
test('Remove Click Handler', function() {
var field = new Blockly.FieldImage('src', 10, 10, null, this.onClick);
field.setOnClickHandler(null);
chai.assert.equal(field.clickHandler_, null);
chai.assert.isNull(field.clickHandler_);
});
});
suite('Alt', function() {

4
tests/mocha/field_label_serializable_test.js
View File

@@ -8,8 +8,8 @@ suite('Label Serializable Fields', function() {
function assertValue(labelField, expectedValue) {
var actualValue = labelField.getValue();
var actualText = labelField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedValue);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedValue);
}
function assertValueDefault(labelField) {
assertValue(labelField, '');

4
tests/mocha/field_label_test.js
View File

@@ -8,8 +8,8 @@ suite('Label Fields', function() {
function assertValue(labelField, expectedValue) {
var actualValue = labelField.getValue();
var actualText = labelField.getText();
assertEquals(actualValue, expectedValue);
assertEquals(actualText, expectedValue);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, expectedValue);
}
function assertValueDefault(labelField) {
assertValue(labelField, '');

12
tests/mocha/field_number_test.js
View File

@@ -9,9 +9,9 @@ suite('Number Fields', function() {
var actualValue = numberField.getValue();
var actualText = numberField.getText();
opt_expectedText = opt_expectedText || String(expectedValue);
assertEquals(String(actualValue), String(expectedValue));
assertEquals(Number(actualValue), expectedValue);
assertEquals(actualText, opt_expectedText);
chai.assert.equal(String(actualValue), String(expectedValue));
chai.assert.equal(Number(actualValue), expectedValue);
chai.assert.equal(actualText, opt_expectedText);
}
function assertValueDefault(numberField) {
assertValue(numberField, 0);
@@ -244,7 +244,7 @@ suite('Number Fields', function() {
test('Null', function() {
var numberField = new Blockly.FieldNumber
.fromJson({ precision: null});
assertEquals(numberField.getPrecision(), 0);
chai.assert.equal(numberField.getPrecision(), 0);
});
});
suite('Min', function() {
@@ -278,7 +278,7 @@ suite('Number Fields', function() {
test('Null', function() {
var numberField = new Blockly.FieldNumber
.fromJson({ min: null});
assertEquals(numberField.getMin(), -Infinity);
chai.assert.equal(numberField.getMin(), -Infinity);
});
});
suite('Max', function() {
@@ -312,7 +312,7 @@ suite('Number Fields', function() {
test('null', function() {
var numberField = new Blockly.FieldNumber
.fromJson({ max: null});
assertEquals(numberField.getMax(), Infinity);
chai.assert.equal(numberField.getMax(), Infinity);
});
});
});

4
tests/mocha/field_registry_test.js
View File

@@ -82,7 +82,7 @@ suite('Field Registry', function() {
var field = Blockly.fieldRegistry.fromJson(json);
chai.assert.isNotNull(field);
chai.assert.equal('ok', field.getValue());
chai.assert.equal(field.getValue(), 'ok');
});
test('Not Registered', function() {
var json = {
@@ -106,7 +106,7 @@ suite('Field Registry', function() {
var field = Blockly.fieldRegistry.fromJson(json);
chai.assert.isNotNull(field);
chai.assert.equal('ok', field.getValue());
chai.assert.equal(field.getValue(), 'ok');
});
});
});

8
tests/mocha/field_test.js
View File

@@ -36,26 +36,26 @@ suite('Abstract Fields', function() {
// An old default field should be serialized.
var field = new FieldDefault();
var stub = sinon.stub(console, 'warn');
assertEquals(true, field.isSerializable());
chai.assert.isTrue(field.isSerializable());
chai.assert(stub.calledOnce);
stub.restore();
});
test('Editable False, Serializable Default(false)', function() {
// An old non-editable field should not be serialized.
var field = new FieldFalseDefault();
assertEquals(false, field.isSerializable());
chai.assert.isFalse(field.isSerializable());
});
/* Test Other Cases */
test('Editable Default(true), Serializable True', function() {
// A field that is both editable and serializable should be serialized.
var field = new FieldDefaultTrue();
assertEquals(true, field.isSerializable());
chai.assert.isTrue(field.isSerializable());
});
test('Editable False, Serializable True', function() {
// A field that is not editable, but overrides serializable to true
// should be serialized (e.g. field_label_serializable)
var field = new FieldFalseTrue();
assertEquals(true, field.isSerializable());
chai.assert.isTrue(field.isSerializable());
});
});
suite('setValue', function() {

4
tests/mocha/field_textinput_test.js
View File

@@ -9,8 +9,8 @@ suite('Text Input Fields', function() {
var actualValue = textInputField.getValue();
var actualText = textInputField.getText();
opt_expectedText = opt_expectedText || expectedValue;
assertEquals(actualValue, expectedValue);
assertEquals(actualText, opt_expectedText);
chai.assert.equal(actualValue, expectedValue);
chai.assert.equal(actualText, opt_expectedText);
}
function assertValueDefault(textInputField) {
assertValue(textInputField, '');

45
tests/mocha/field_variable_test.js
View File

@@ -36,8 +36,8 @@ suite('Variable Fields', function() {
var actualName = variableField.getText();
var actualId = variableField.getValue();
opt_expectedId = opt_expectedId || FAKE_ID;
assertEquals(actualName, expectedName);
assertEquals(actualId, opt_expectedId);
chai.assert.equal(actualName, expectedName);
chai.assert.equal(actualId, opt_expectedId);
}
function assertValueDefault(variableField) {
assertValue(variableField, FAKE_VARIABLE_NAME, FAKE_ID);
@@ -69,10 +69,10 @@ suite('Variable Fields', function() {
fieldVariable);
// Expect three variable options, a rename option, and a delete option.
assertEquals(result_options.length, 5);
isEqualArrays(result_options[0], ['name1', 'id1']);
isEqualArrays(result_options[1], ['name2', 'id2']);
isEqualArrays(result_options[2], ['name3', 'id3']);
chai.assert.equal(result_options.length, 5);
assertArrayEquals(result_options[0], ['name1', 'id1']);
assertArrayEquals(result_options[1], ['name2', 'id2']);
assertArrayEquals(result_options[2], ['name3', 'id3']);
});
suite('Constructor', function() {
test('Null', function() {
@@ -86,8 +86,8 @@ suite('Variable Fields', function() {
});
test('No Value Before InitModel', function() {
var fieldVariable = new Blockly.FieldVariable('name1');
assertEquals('', fieldVariable.getText());
assertNull(fieldVariable.getValue());
chai.assert.equal(fieldVariable.getText(), '');
chai.assert.isNull(fieldVariable.getValue());
});
test('Given Variable Name', function() {
var fieldVariable = createAndInitFieldConstructor(
@@ -106,8 +106,8 @@ suite('Variable Fields', function() {
});
test('No Value Before InitModel', function() {
var variableField = new Blockly.FieldVariable('name1');
assertEquals('', variableField.getText());
assertNull(variableField.getValue());
chai.assert.equal(variableField.getText(), '');
chai.assert.isNull(variableField.getValue());
});
test('Given Variable Name', function() {
var variableField = createAndInitFieldJson(this.workspace, 'name1');
@@ -139,8 +139,8 @@ suite('Variable Fields', function() {
variableField.setValue('id2');
// Setting value by ID gives us the right text as well.
assertEquals('name2', variableField.getText());
assertEquals('id2', variableField.getValue());
chai.assert.equal(variableField.getText(), 'name2');
chai.assert.equal(variableField.getValue(), 'id2');
chai.assert.notEqual(oldId, variableField.getValue());
});
test('Variable Does not Exist', function() {
@@ -244,7 +244,7 @@ suite('Variable Fields', function() {
// will be returned (regardless of what types are available on the workspace).
var fieldVariable = new Blockly.FieldVariable('name1');
var resultTypes = fieldVariable.getVariableTypes_();
isEqualArrays(resultTypes, ['']);
assertArrayEquals(resultTypes, ['']);
});
test('variableTypes is explicit', function() {
// Expect that since variableTypes is defined, it will be the return
@@ -252,9 +252,9 @@ suite('Variable Fields', function() {
var fieldVariable = new Blockly.FieldVariable(
'name1', null, ['type1', 'type2'], 'type1');
var resultTypes = fieldVariable.getVariableTypes_();
isEqualArrays(resultTypes, ['type1', 'type2']);
assertEquals('Default type was wrong', 'type1',
fieldVariable.defaultType_);
assertArrayEquals(resultTypes, ['type1', 'type2']);
chai.assert.equal(fieldVariable.defaultType_, 'type1',
'Default type was wrong');
});
test('variableTypes is null', function() {
// Expect all variable types to be returned.
@@ -267,7 +267,7 @@ suite('Variable Fields', function() {
var resultTypes = fieldVariable.getVariableTypes_();
// The empty string is always one of the options.
isEqualArrays(resultTypes, ['type1', 'type2', '']);
assertArrayEquals(resultTypes, ['type1', 'type2', '']);
});
test('variableTypes is the empty list', function() {
var fieldVariable = new Blockly.FieldVariable('name1');
@@ -283,15 +283,14 @@ suite('Variable Fields', function() {
suite('Default types', function() {
test('Default type exists', function() {
var fieldVariable = new Blockly.FieldVariable(null, null, ['b'], 'b');
assertEquals('The variable field\'s default type should be "b"',
'b', fieldVariable.defaultType_);
chai.assert.equal(fieldVariable.defaultType_, 'b',
'The variable field\'s default type should be "b"');
});
test('No default type', function() {
var fieldVariable = new Blockly.FieldVariable(null);
assertEquals('The variable field\'s default type should be the empty string',
'', fieldVariable.defaultType_);
assertNull('The variable field\'s allowed types should be null',
fieldVariable.variableTypes);
chai.assert.equal(fieldVariable.defaultType_, '', 'The variable field\'s default type should be the empty string');
chai.assert.isNull(fieldVariable.variableTypes,
'The variable field\'s allowed types should be null');
});
test('Default type mismatch', function() {
// Invalid default type when creating a variable field.

10
tests/mocha/gesture_test.js
View File

@@ -24,8 +24,8 @@ suite('Gesture', function() {
test('Constructor', function() {
var gesture = new Blockly.Gesture(this.e, this.workspace);
assertEquals(gesture.mostRecentEvent_, this.e);
assertEquals(gesture.creatorWorkspace_, this.workspace);
chai.assert.equal(gesture.mostRecentEvent_, this.e);
chai.assert.equal(gesture.creatorWorkspace_, this.workspace);
});
test('Field click - Click in workspace', function() {
@@ -37,7 +37,7 @@ suite('Gesture', function() {
gesture.setStartField(field);
var isFieldClick = gesture.isFieldClick_();
assertEquals(isFieldClick, true);
chai.assert.isTrue(isFieldClick);
});
function gestureIsFieldClick_InFlyoutHelper(flyout, expectedResult){
@@ -55,7 +55,7 @@ suite('Gesture', function() {
gesture.setStartFlyout_(this.workspace.flyout_);
var isFieldClick = gesture.isFieldClick_();
assertEquals(isFieldClick, expectedResult);
chai.assert.equal(isFieldClick, expectedResult);
}
test('Field click - Auto close flyout', function() {
@@ -82,6 +82,6 @@ suite('Gesture', function() {
var gesture = new Blockly.Gesture(event, ws);
gesture.doWorkspaceClick_(event);
var cursor = ws.getCursor();
assertEquals(cursor.getCurNode().getType(), Blockly.ASTNode.types.WORKSPACE);
chai.assert.equal(cursor.getCurNode().getType(), Blockly.ASTNode.types.WORKSPACE);
});
});

139
tests/mocha/json_test.js
View File

@@ -61,11 +61,10 @@ suite('JSON Block Definitions', function() {
});
this.blocks_.push(block);
assertNotNull(block);
assertEquals(BLOCK_TYPE, block.type);
assertEquals(
'Expecting no warnings when defining and creating a simple block.',
warnings.length, 0);
chai.assert.isNotNull(block);
chai.assert.equal(BLOCK_TYPE, block.type);
chai.assert.equal(warnings.length, 0,
'Expecting no warnings when defining and creating a simple block.');
});
test('Null or undefined type id', function() {
@@ -74,8 +73,8 @@ suite('JSON Block Definitions', function() {
this.blockTypes_.push(BLOCK_TYPE1);
this.blockTypes_.push(BLOCK_TYPE2);
assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
var blockTypeCount = Object.keys(Blockly.Blocks).length;
var warnings = captureWarnings(function() {
@@ -86,13 +85,13 @@ suite('JSON Block Definitions', function() {
{"type": BLOCK_TYPE2}]);
});
assertNotNullNorUndefined('Block before bad blocks should be defined.',
Blockly.Blocks[BLOCK_TYPE1]);
assertNotNullNorUndefined('Block after bad blocks should be defined.',
Blockly.Blocks[BLOCK_TYPE2]);
assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
assertEquals(
'Expecting 2 warnings, one for each bad block.', warnings.length, 2);
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
'Block before bad blocks should be defined.');
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
'Block after bad blocks should be defined.');
chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
chai.assert.equal(warnings.length, 2,
'Expecting 2 warnings, one for each bad block.');
});
test('Null item', function() {
@@ -101,8 +100,8 @@ suite('JSON Block Definitions', function() {
this.blockTypes_.push(BLOCK_TYPE1);
this.blockTypes_.push(BLOCK_TYPE2);
assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
var blockTypeCount = Object.keys(Blockly.Blocks).length;
var warnings = captureWarnings(function() {
@@ -117,14 +116,12 @@ suite('JSON Block Definitions', function() {
"message0": 'after'
}]);
});
assertNotNullNorUndefined(
'Block before null in array should be defined.',
Blockly.Blocks[BLOCK_TYPE1]);
assertNotNullNorUndefined(
'Block after null in array should be defined.',
Blockly.Blocks[BLOCK_TYPE2]);
assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
assertEquals('Expected 1 warning for the bad block.', warnings.length, 1);
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
'Block before null in array should be defined.');
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
'Block after null in array should be defined.');
chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
chai.assert.equal(warnings.length, 1, 'Expected 1 warning for the bad block.');
});
test('Undefined item', function() {
@@ -133,8 +130,8 @@ suite('JSON Block Definitions', function() {
this.blockTypes_.push(BLOCK_TYPE1);
this.blockTypes_.push(BLOCK_TYPE2);
assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
var blockTypeCount = Object.keys(Blockly.Blocks).length;
var warnings = captureWarnings(function() {
Blockly.defineBlocksWithJsonArray([
@@ -148,14 +145,12 @@ suite('JSON Block Definitions', function() {
"message0": 'after'
}]);
});
assertNotNullNorUndefined(
'Block before undefined in array should be defined.',
Blockly.Blocks[BLOCK_TYPE1]);
assertNotNullNorUndefined(
'Block after undefined in array should be defined.',
Blockly.Blocks[BLOCK_TYPE2]);
assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
assertEquals('Expected 1 warning for the bad block.', warnings.length, 1);
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
'Block before undefined in array should be defined.');
chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
'Block after undefined in array should be defined.');
chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
chai.assert.equal( warnings.length, 1, 'Expected 1 warning for the bad block.');
});
test('message0 creates input', function() {
@@ -168,11 +163,11 @@ suite('JSON Block Definitions', function() {
}]);
var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
assertEquals(1, block.inputList.length);
assertEquals(1, block.inputList[0].fieldRow.length);
chai.assert.equal(1, block.inputList.length);
chai.assert.equal(1, block.inputList[0].fieldRow.length);
var textField = block.inputList[0].fieldRow[0];
assertEquals(Blockly.FieldLabel, textField.constructor);
assertEquals(MESSAGE0, textField.getText());
chai.assert.equal(Blockly.FieldLabel, textField.constructor);
chai.assert.equal(MESSAGE0, textField.getText());
});
test('message1 and message0 creates two inputs', function() {
@@ -189,17 +184,17 @@ suite('JSON Block Definitions', function() {
var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
this.blocks_.push(block);
assertEquals(2, block.inputList.length);
chai.assert.equal(2, block.inputList.length);
assertEquals(1, block.inputList[0].fieldRow.length);
chai.assert.equal(1, block.inputList[0].fieldRow.length);
var textField = block.inputList[0].fieldRow[0];
assertEquals(Blockly.FieldLabel, textField.constructor);
assertEquals(MESSAGE0, textField.getText());
chai.assert.equal(Blockly.FieldLabel, textField.constructor);
chai.assert.equal(MESSAGE0, textField.getText());
assertEquals(1, block.inputList[1].fieldRow.length);
chai.assert.equal(1, block.inputList[1].fieldRow.length);
var textField = block.inputList[1].fieldRow[0];
assertEquals(Blockly.FieldLabel, textField.constructor);
assertEquals(MESSAGE1, textField.getText());
chai.assert.equal(Blockly.FieldLabel, textField.constructor);
chai.assert.equal(MESSAGE1, textField.getText());
});
test('Message string is dereferenced', function() {
@@ -217,11 +212,11 @@ suite('JSON Block Definitions', function() {
var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
this.blocks_.push(block);
assertEquals(1, block.inputList.length);
assertEquals(1, block.inputList[0].fieldRow.length);
chai.assert.equal(1, block.inputList.length);
chai.assert.equal(1, block.inputList[0].fieldRow.length);
var textField = block.inputList[0].fieldRow[0];
assertEquals(Blockly.FieldLabel, textField.constructor);
assertEquals(MESSAGE, textField.getText());
chai.assert.equal(Blockly.FieldLabel, textField.constructor);
chai.assert.equal(MESSAGE, textField.getText());
});
test('Dropdown', function() {
@@ -249,18 +244,18 @@ suite('JSON Block Definitions', function() {
var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
this.blocks_.push(block);
assertEquals(1, block.inputList.length);
assertEquals(1, block.inputList[0].fieldRow.length);
chai.assert.equal(1, block.inputList.length);
chai.assert.equal(1, block.inputList[0].fieldRow.length);
var dropdown = block.inputList[0].fieldRow[0];
assertEquals(dropdown, block.getField(FIELD_NAME));
assertEquals(Blockly.FieldDropdown, dropdown.constructor);
assertEquals(VALUE0, dropdown.getValue());
chai.assert.equal(dropdown, block.getField(FIELD_NAME));
chai.assert.equal(Blockly.FieldDropdown, dropdown.constructor);
chai.assert.equal(VALUE0, dropdown.getValue());
var options = dropdown.getOptions();
assertEquals(LABEL0, options[0][0]);
assertEquals(VALUE0, options[0][1]);
assertEquals(LABEL1, options[1][0]);
assertEquals(VALUE1, options[1][1]);
chai.assert.equal(LABEL0, options[0][0]);
chai.assert.equal(VALUE0, options[0][1]);
chai.assert.equal(LABEL1, options[1][0]);
chai.assert.equal(VALUE1, options[1][1]);
});
@@ -310,34 +305,34 @@ suite('JSON Block Definitions', function() {
var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
this.blocks_.push(block);
assertEquals(1, block.inputList.length);
assertEquals(1, block.inputList[0].fieldRow.length);
chai.assert.equal(1, block.inputList.length);
chai.assert.equal(1, block.inputList[0].fieldRow.length);
var dropdown = block.inputList[0].fieldRow[0];
assertEquals(dropdown, block.getField(FIELD_NAME));
assertEquals(Blockly.FieldDropdown, dropdown.constructor);
assertEquals(VALUE0, dropdown.getValue());
chai.assert.equal(dropdown, block.getField(FIELD_NAME));
chai.assert.equal(Blockly.FieldDropdown, dropdown.constructor);
chai.assert.equal(VALUE0, dropdown.getValue());
function assertImageEquals(actualImage, expectedImage) {
assertEquals(actualImage.width, expectedImage.width);
assertEquals(actualImage.height, expectedImage.height);
assertEquals(actualImage.src, expectedImage.src);
chai.assert.equal(actualImage.width, expectedImage.width);
chai.assert.equal(actualImage.height, expectedImage.height);
chai.assert.equal(actualImage.src, expectedImage.src);
}
var options = dropdown.getOptions();
var image0 = options[0][0];
assertImageEquals(IMAGE0, image0);
assertEquals(IMAGE0.alt, image0.alt);
assertEquals(options[0][1], VALUE0);
chai.assert.equal(IMAGE0.alt, image0.alt);
chai.assert.equal(options[0][1], VALUE0);
var image1 = options[1][0];
assertImageEquals(IMAGE1, image1);
assertEquals(IMAGE1.alt, IMAGE1_ALT_TEXT); // Via Msg reference
assertEquals(VALUE1, options[1][1]);
chai.assert.equal(IMAGE1.alt, IMAGE1_ALT_TEXT); // Via Msg reference
chai.assert.equal(VALUE1, options[1][1]);
var image2 = options[2][0];
assertImageEquals(IMAGE1, image1);
assert(image2.alt == null); // No alt specified.
assertEquals(VALUE2, options[2][1]);
chai.assert.notExists(image2.alt); // No alt specified.
chai.assert.equal(VALUE2, options[2][1]);
});
});
});

24
tests/mocha/key_map_test.js
View File

@@ -14,38 +14,38 @@ suite('Key Map Tests', function() {
return "test";
});
Blockly.user.keyMap.setActionForKey('65', newAction);
assertEquals(Blockly.user.keyMap.map_['65'].name, 'test_action');
chai.assert.equal(Blockly.user.keyMap.map_['65'].name, 'test_action');
});
test('Test giving an old action a new key', function() {
Blockly.user.keyMap.setActionForKey(Blockly.utils.KeyCodes.F,
Blockly.navigation.ACTION_PREVIOUS);
assertEquals(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.W], undefined);
assertEquals(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.F],
chai.assert.isUndefined(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.W]);
chai.assert.equal(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.F],
Blockly.navigation.ACTION_PREVIOUS);
});
test('Test get key by action defined', function() {
var key = Blockly.user.keyMap.getKeyByAction(Blockly.navigation.ACTION_PREVIOUS);
assertEquals(key, Blockly.utils.KeyCodes.W);
chai.assert.equal(key, Blockly.utils.KeyCodes.W);
});
test('Test get key by action undefined', function() {
test('Test get key by action not defined', function() {
var key = Blockly.user.keyMap.getKeyByAction(new Blockly.Action('something'));
assertEquals(key, undefined);
chai.assert.notExists(key);
});
test('Test set key map', function() {
var testKeyMap = Blockly.user.keyMap.createDefaultKeyMap();
testKeyMap['randomKey'] = new Blockly.Action('test','',null);
Blockly.user.keyMap.setKeyMap(testKeyMap);
assertEquals(Blockly.user.keyMap.map_['randomKey'].name, 'test');
chai.assert.equal(Blockly.user.keyMap.map_['randomKey'].name, 'test');
});
test('Test get key map returns a clone', function() {
var keyMap = Blockly.user.keyMap.getKeyMap();
keyMap['randomKey'] = new Blockly.Action('test', '', null);
assertEquals(Blockly.user.keyMap.map_['randomKey'], undefined);
chai.assert.isUndefined(Blockly.user.keyMap.map_['randomKey']);
});
test('Test serialize key code with modifiers', function() {
@@ -56,7 +56,7 @@ suite('Key Map Tests', function() {
keyCode: 65
};
var serializedKey = Blockly.user.keyMap.serializeKeyEvent(mockEvent);
assertEquals(serializedKey, 'ShiftControlAltMeta65');
chai.assert.equal(serializedKey, 'ShiftControlAltMeta65');
});
test('Test serialize key code without modifiers', function() {
@@ -67,7 +67,7 @@ suite('Key Map Tests', function() {
keyCode: 65
};
var serializedKey = Blockly.user.keyMap.serializeKeyEvent(mockEvent);
assertEquals(serializedKey, '65');
chai.assert.equal(serializedKey, '65');
});
test('Test modifiers in reverse order', function() {
@@ -76,8 +76,8 @@ suite('Key Map Tests', function() {
Blockly.user.keyMap.modifierKeys.SHIFT]);
Blockly.user.keyMap.setActionForKey(testKey, new Blockly.Action('test', '', null));
var action = Blockly.user.keyMap.getActionByKeyCode('ShiftControl75');
assertNotNull(action);
assertEquals(action.name, 'test');
chai.assert.isNotNull(action);
chai.assert.equal(action.name, 'test');
});
test('Test report invalid modifiers', function() {

8
tests/mocha/metrics_test.js
View File

@@ -12,10 +12,10 @@
suite('Metrics', function() {
function assertDimensionsMatch(toCheck, left, top, width, height) {
assertEquals('Top did not match.', top, toCheck.top);
assertEquals('Left did not match.', left, toCheck.left);
assertEquals('Width did not match.', width, toCheck.width);
assertEquals('Height did not match.', height, toCheck.height);
chai.assert.equal(top, toCheck.top, 'Top did not match.');
chai.assert.equal(left, toCheck.left, 'Left did not match.');
chai.assert.equal(width, toCheck.width, 'Width did not match.');
chai.assert.equal(height, toCheck.height, 'Height did not match.');
}
// Make a mock workspace object with two properties:

51
tests/mocha/names_test.js
View File

@@ -14,44 +14,43 @@ suite('Names', function() {
test('Safe name', function() {
var varDB = new Blockly.Names('window,door');
assertEquals('SafeName empty.', 'unnamed', varDB.safeName_(''));
assertEquals('SafeName ok.', 'foobar', varDB.safeName_('foobar'));
assertEquals('SafeName number start.', 'my_9lives',
varDB.safeName_('9lives'));
assertEquals('SafeName number end.', 'lives9', varDB.safeName_('lives9'));
assertEquals('SafeName special chars.', '____', varDB.safeName_('!@#$'));
assertEquals('SafeName reserved.', 'door', varDB.safeName_('door'));
chai.assert.equal(varDB.safeName_(''), 'unnamed','SafeName empty.');
chai.assert.equal( varDB.safeName_('foobar'), 'foobar','SafeName ok.');
chai.assert.equal(varDB.safeName_('9lives'), 'my_9lives', 'SafeName number start.');
chai.assert.equal(varDB.safeName_('lives9'), 'lives9', 'SafeName number end.');
chai.assert.equal(varDB.safeName_('!@#$'), '____', 'SafeName special chars.');
chai.assert.equal(varDB.safeName_('door'), 'door', 'SafeName reserved.');
});
test('Get name', function() {
var varDB = new Blockly.Names('window,door');
assertEquals('Name add #1.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
assertEquals('Name get #1.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
assertEquals('Name add #2.', 'Foo_bar2', varDB.getName('Foo bar', 'var'));
assertEquals('Name get #2.', 'Foo_bar2', varDB.getName('foo BAR', 'var'));
assertEquals('Name add #3.', 'door2', varDB.getName('door', 'var'));
assertEquals('Name add #4.', 'Foo_bar3', varDB.getName('Foo.bar', 'proc'));
assertEquals('Name get #1b.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
assertEquals('Name get #4.', 'Foo_bar3', varDB.getName('Foo.bar', 'proc'));
chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name add #1.');
chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name get #1.');
chai.assert.equal(varDB.getName('Foo bar', 'var'), 'Foo_bar2', 'Name add #2.');
chai.assert.equal(varDB.getName('foo BAR', 'var'), 'Foo_bar2', 'Name get #2.');
chai.assert.equal(varDB.getName('door', 'var'), 'door2', 'Name add #3.');
chai.assert.equal(varDB.getName('Foo.bar', 'proc'), 'Foo_bar3', 'Name add #4.');
chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name get #1b.');
chai.assert.equal(varDB.getName('Foo.bar', 'proc'), 'Foo_bar3', 'Name get #4.');
});
test('Get distinct name', function() {
var varDB = new Blockly.Names('window,door');
assertEquals('Name distinct #1.', 'Foo_bar',
varDB.getDistinctName('Foo.bar', 'var'));
assertEquals('Name distinct #2.', 'Foo_bar2',
varDB.getDistinctName('Foo.bar', 'var'));
assertEquals('Name distinct #3.', 'Foo_bar3',
varDB.getDistinctName('Foo.bar', 'proc'));
chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar',
'Name distinct #1.');
chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar2',
'Name distinct #2.');
chai.assert.equal(varDB.getDistinctName('Foo.bar', 'proc'), 'Foo_bar3',
'Name distinct #3.');
varDB.reset();
assertEquals('Name distinct #4.', 'Foo_bar',
varDB.getDistinctName('Foo.bar', 'var'));
chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar',
'Name distinct #4.');
});
test('name equals', function() {
assertTrue('Name equals #1.', Blockly.Names.equals('Foo.bar', 'Foo.bar'));
assertFalse('Name equals #2.', Blockly.Names.equals('Foo.bar', 'Foo_bar'));
assertTrue('Name equals #3.', Blockly.Names.equals('Foo.bar', 'FOO.BAR'));
chai.assert.isTrue(Blockly.Names.equals('Foo.bar', 'Foo.bar'), 'Name equals #1.');
chai.assert.isFalse(Blockly.Names.equals('Foo.bar', 'Foo_bar'), 'Name equals #2.');
chai.assert.isTrue(Blockly.Names.equals('Foo.bar', 'FOO.BAR'), 'Name equals #3.');
});
});

2
tests/mocha/navigation_modify_test.js
View File

@@ -195,7 +195,7 @@ suite('Insert/Modify', function() {
Blockly.ASTNode.createConnectionNode(
this.row_block_1.outputConnection));
chai.assert.isFalse(Blockly.navigation.modify_());
chai.assert.equal(this.row_block_1.getParent(), null);
chai.assert.isNull(this.row_block_1.getParent());
});
});

4
tests/mocha/navigation_test.js
View File

@@ -662,7 +662,7 @@ suite('Navigation', function() {
Blockly.navigation.connect_(cursorLocation, markedLocation);
chai.assert.equal(this.basicBlock.nextConnection.targetBlock(), this.basicBlock4);
chai.assert.equal(this.basicBlock3.nextConnection.targetConnection, null);
chai.assert.isNull(this.basicBlock3.nextConnection.targetConnection);
});
test('Connect cursor with parents', function() {
@@ -680,7 +680,7 @@ suite('Navigation', function() {
Blockly.navigation.connect_(cursorLocation, markedLocation);
chai.assert.equal(this.inlineBlock2.outputConnection.targetBlock(), null);
chai.assert.isNull(this.inlineBlock2.outputConnection.targetBlock());
chai.assert.equal(this.inlineBlock1.outputConnection.targetBlock(), this.inlineBlock2);
});
});

141
tests/mocha/test_helpers.js
View File

@@ -4,141 +4,24 @@
* SPDX-License-Identifier: Apache-2.0
*/
/* exported assertEquals, assertNotEquals, assertArrayEquals, assertTrue, assertFalse,
assertNull, assertNotNull, assertNotNullNorUndefined, assert,
isEqualArrays, assertUndefined, assertNotUndefined, assertVariableValues,
defineRowBlock, defineStackBlock, defineStatementBlock, createTestBlock */
function _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) {
return args.length == expectedNumberOfNonCommentArgs + 1;
}
function _commentArg(expectedNumberOfNonCommentArgs, args) {
if (_argumentsIncludeComments(expectedNumberOfNonCommentArgs, args)) {
return args[0];
}
return null;
}
function _nonCommentArg(desiredNonCommentArgIndex, expectedNumberOfNonCommentArgs, args) {
return _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) ?
args[desiredNonCommentArgIndex] :
args[desiredNonCommentArgIndex - 1];
}
function _validateArguments(expectedNumberOfNonCommentArgs, args) {
if (!( args.length == expectedNumberOfNonCommentArgs ||
(args.length == expectedNumberOfNonCommentArgs + 1 && (typeof(args[0]) == 'string') || args[0] == null))) {
throw Error('Incorrect arguments passed to assert function');
}
}
/**
* Converts from JSUnit assertEquals to chai.assert.equal.
*/
function assertEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
var comment = _commentArg(2, arguments);
chai.assert.equal(var1, var2, comment);
}
/**
* Converts from JSUnit assertNotEquals to chai.assert.notEquals.
*/
function assertNotEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
var comment = _commentArg(2, arguments);
chai.assert.notEqual(var1, var2, comment);
}
/**
* Converts from JSUnit assertTrue to chai.assert.isTrue.
*/
function assertTrue() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var booleanValue = _nonCommentArg(1, 1, arguments);
if (typeof(booleanValue) != 'boolean') {
throw Error('Bad argument to assertTrue(boolean)');
}
chai.assert.isTrue(booleanValue, commentArg);
}
/**
* Converts from JSUnit assertFalse to chai.assert.isNotTrue.
*/
function assertFalse() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var booleanValue = _nonCommentArg(1, 1, arguments);
if (typeof(booleanValue) != 'boolean') {
throw Error('Bad argument to assertFalse(boolean)');
}
chai.assert.isNotTrue(booleanValue, commentArg);
}
/**
* Converts from JSUnit assertNull to chai.assert.isNull.
*/
function assertNull() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isNull(val, commentArg);
}
function assertNotNull() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isNotNull(val, commentArg);
}
function assertNotNullNorUndefined() {
assertNotNull(arguments);
}
function assert() {
chai.assert(arguments);
}
/* exported assertArrayEquals, assertVariableValues, defineRowBlock,
defineStackBlock, defineStatementBlock, createTestBlock */
/**
* Check that two arrays have the same content.
* @param {!Array.<string>} array1 The first array.
* @param {!Array.<string>} array2 The second array.
* @param {?string} opt_message Optional message to pass into assert.
*/
function isEqualArrays(array1, array2) {
assertEquals(array1.length, array2.length);
function isEqualArrays(array1, array2, opt_message) {
chai.assert.equal(array1.length, array2.length, opt_message);
for (var i = 0; i < array1.length; i++) {
assertEquals(array1[i], array2[i]);
chai.assert.equal(array1[i], array2[i], opt_message);
}
}
function assertUndefined() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isUndefined(val, commentArg);
}
function assertNotUndefined() {
_validateArguments(1, arguments);
var commentArg = _commentArg(1, arguments);
var val = _nonCommentArg(1, 1, arguments);
chai.assert.isDefined(val, commentArg);
}
function assertArrayEquals() {
_validateArguments(2, arguments);
var var1 = _nonCommentArg(1, 2, arguments);
var var2 = _nonCommentArg(2, 2, arguments);
isEqualArrays(var1, var2);
function assertArrayEquals(actualArray, expectedArray, opt_message) {
isEqualArrays(actualArray, expectedArray, opt_message);
}
/**
@@ -151,10 +34,10 @@ function assertArrayEquals() {
*/
function assertVariableValues(container, name, type, id) {
var variable = container.getVariableById(id);
assertNotNull(variable);
assertEquals(name, variable.name);
assertEquals(type, variable.type);
assertEquals(id, variable.getId());
chai.assert.isDefined(variable);
chai.assert.equal(variable.name, name);
chai.assert.equal(variable.type, type);
chai.assert.equal(variable.getId(), id);
}
function defineStackBlock() {

8
tests/mocha/theme_test.js
View File

@@ -69,7 +69,7 @@ suite('Theme', function() {
function stringifyAndCompare(val1, val2) {
var stringVal1 = JSON.stringify(val1);
var stringVal2 = JSON.stringify(val2);
assertEquals(stringVal1, stringVal2);
chai.assert.equal(stringVal1, stringVal2);
}
test('Set All BlockStyles', function() {
@@ -136,12 +136,12 @@ suite('Theme', function() {
stringifyAndCompare(workspace.getTheme(), blockStyles);
// Checks that the setTheme function was called on the block
assertEquals(blockA.getStyleName(), 'styleTwo');
chai.assert.equal(blockA.getStyleName(), 'styleTwo');
// check that the toolbox refreshed method was called
assertEquals(workspace.refreshToolboxSelection(), 3);
chai.assert.equal(workspace.refreshToolboxSelection(), 3);
assertEquals(Blockly.Events.FIRE_QUEUE_.pop().element, 'theme');
chai.assert.equal(Blockly.Events.FIRE_QUEUE_.pop().element, 'theme');
undefineThemeTestBlocks();

250
tests/mocha/utils_test.js
View File

@@ -18,71 +18,71 @@ suite('Utils', function() {
suite('tokenizeInterpolation', function() {
test('Basic', function() {
var tokens = Blockly.utils.tokenizeInterpolation('');
assertArrayEquals('Null interpolation', [], tokens);
assertArrayEquals(tokens, [], 'Null interpolation');
tokens = Blockly.utils.tokenizeInterpolation('Hello');
assertArrayEquals('No interpolation', ['Hello'], tokens);
assertArrayEquals(tokens, ['Hello'], 'No interpolation');
tokens = Blockly.utils.tokenizeInterpolation('Hello%World');
assertArrayEquals('Unescaped %.', ['Hello%World'], tokens);
assertArrayEquals(tokens, ['Hello%World'], 'Unescaped %.');
tokens = Blockly.utils.tokenizeInterpolation('Hello%%World');
assertArrayEquals('Escaped %.', ['Hello%World'], tokens);
assertArrayEquals(tokens, ['Hello%World'], 'Escaped %.');
tokens = Blockly.utils.tokenizeInterpolation('Hello %1 World');
assertArrayEquals('Interpolation.', ['Hello ', 1, ' World'], tokens);
assertArrayEquals(tokens, ['Hello ', 1, ' World'], 'Interpolation.');
tokens = Blockly.utils.tokenizeInterpolation('%123Hello%456World%789');
assertArrayEquals('Interpolations.', [123, 'Hello', 456, 'World', 789], tokens);
assertArrayEquals(tokens, [123, 'Hello', 456, 'World', 789], 'Interpolations.');
tokens = Blockly.utils.tokenizeInterpolation('%%%x%%0%00%01%');
assertArrayEquals('Torture interpolations.', ['%%x%0', 0, 1, '%'], tokens);
assertArrayEquals(tokens, ['%%x%0', 0, 1, '%'], 'Torture interpolations.');
});
test('String table', function() {
Blockly.Msg = Blockly.Msg || {};
Blockly.Msg.STRING_REF = 'test string';
var tokens = Blockly.utils.tokenizeInterpolation('%{bky_string_ref}');
assertArrayEquals('String table reference, lowercase', ['test string'], tokens);
assertArrayEquals(tokens, ['test string'], 'String table reference, lowercase');
tokens = Blockly.utils.tokenizeInterpolation('%{BKY_STRING_REF}');
assertArrayEquals('String table reference, uppercase', ['test string'], tokens);
assertArrayEquals(tokens, ['test string'], 'String table reference, uppercase');
Blockly.Msg.WITH_PARAM = 'before %1 after';
tokens = Blockly.utils.tokenizeInterpolation('%{bky_with_param}');
assertArrayEquals('String table reference, with parameter', ['before ', 1, ' after'], tokens);
assertArrayEquals(tokens, ['before ', 1, ' after'], 'String table reference, with parameter');
Blockly.Msg.RECURSE = 'before %{bky_string_ref} after';
tokens = Blockly.utils.tokenizeInterpolation('%{bky_recurse}');
assertArrayEquals('String table reference, with subreference', ['before test string after'], tokens);
assertArrayEquals(tokens, ['before test string after'], 'String table reference, with subreference');
});
test('Error cases', function() {
var tokens = Blockly.utils.tokenizeInterpolation('%{bky_undefined}');
assertArrayEquals('Undefined string table reference', ['%{bky_undefined}'], tokens);
assertArrayEquals(tokens, ['%{bky_undefined}'], 'Undefined string table reference');
Blockly.Msg['1'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{1} after');
assertArrayEquals('Invalid initial digit in string table reference', ['before %{1} after'], tokens);
assertArrayEquals(tokens, ['before %{1} after'], 'Invalid initial digit in string table reference');
Blockly.Msg['TWO WORDS'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{two words} after');
assertArrayEquals('Invalid character in string table reference: space', ['before %{two words} after'], tokens);
assertArrayEquals(tokens, ['before %{two words} after'], 'Invalid character in string table reference: space');
Blockly.Msg['TWO-WORDS'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{two-words} after');
assertArrayEquals('Invalid character in string table reference: dash', ['before %{two-words} after'], tokens);
assertArrayEquals(tokens, ['before %{two-words} after'], 'Invalid character in string table reference: dash');
Blockly.Msg['TWO.WORDS'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{two.words} after');
assertArrayEquals('Invalid character in string table reference: period', ['before %{two.words} after'], tokens);
assertArrayEquals(tokens, ['before %{two.words} after'], 'Invalid character in string table reference: period');
Blockly.Msg['AB&C'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{ab&c} after');
assertArrayEquals('Invalid character in string table reference: &', ['before %{ab&c} after'], tokens);
assertArrayEquals(tokens, ['before %{ab&c} after'], 'Invalid character in string table reference: &');
Blockly.Msg['UNCLOSED'] = 'Will not match';
tokens = Blockly.utils.tokenizeInterpolation('before %{unclosed');
assertArrayEquals('String table reference, with parameter', ['before %{unclosed'], tokens);
assertArrayEquals(tokens, ['before %{unclosed'], 'String table reference, with parameter');
});
});
@@ -94,252 +94,252 @@ suite('Utils', function() {
Blockly.Msg.STRING_REF_WITH_SUBREF = 'test %{bky_subref} string';
var resultString = Blockly.utils.replaceMessageReferences('');
assertEquals('Empty string produces empty string', '', resultString);
chai.assert.equal(resultString, '', 'Empty string produces empty string');
resultString = Blockly.utils.replaceMessageReferences('%%');
assertEquals('Escaped %', '%', resultString);
chai.assert.equal(resultString, '%', 'Escaped %');
resultString = Blockly.utils.replaceMessageReferences('%%{bky_string_ref}');
assertEquals('Escaped %', '%{bky_string_ref}', resultString);
chai.assert.equal(resultString, '%{bky_string_ref}', 'Escaped %');
resultString = Blockly.utils.replaceMessageReferences('%a');
assertEquals('Unrecognized % escape code treated as literal', '%a', resultString);
chai.assert.equal(resultString, '%a', 'Unrecognized % escape code treated as literal');
resultString = Blockly.utils.replaceMessageReferences('%1');
assertEquals('Interpolation tokens ignored.', '%1', resultString);
chai.assert.equal(resultString, '%1', 'Interpolation tokens ignored.');
resultString = Blockly.utils.replaceMessageReferences('%1 %2');
assertEquals('Interpolation tokens ignored.', '%1 %2', resultString);
chai.assert.equal(resultString, '%1 %2', 'Interpolation tokens ignored.');
resultString = Blockly.utils.replaceMessageReferences('before %1 after');
assertEquals('Interpolation tokens ignored.', 'before %1 after', resultString);
chai.assert.equal(resultString, 'before %1 after', 'Interpolation tokens ignored.');
// Blockly.Msg.STRING_REF cases:
resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref}');
assertEquals('Message ref dereferenced.', 'test string', resultString);
chai.assert.equal(resultString, 'test string', 'Message ref dereferenced.');
resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref} after');
assertEquals('Message ref dereferenced.', 'before test string after', resultString);
chai.assert.equal(resultString, 'before test string after', 'Message ref dereferenced.');
// Blockly.Msg.STRING_REF_WITH_ARG cases:
resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref_with_arg}');
assertEquals('Message ref dereferenced with argument preserved.', 'test %1 string', resultString);
chai.assert.equal(resultString, 'test %1 string', 'Message ref dereferenced with argument preserved.');
resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref_with_arg} after');
assertEquals('Message ref dereferenced with argument preserved.', 'before test %1 string after', resultString);
chai.assert.equal(resultString, 'before test %1 string after', 'Message ref dereferenced with argument preserved.');
// Blockly.Msg.STRING_REF_WITH_SUBREF cases:
resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref_with_subref}');
assertEquals('Message ref and subref dereferenced.', 'test subref string', resultString);
chai.assert.equal(resultString, 'test subref string', 'Message ref and subref dereferenced.');
resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref_with_subref} after');
assertEquals('Message ref and subref dereferenced.', 'before test subref string after', resultString);
chai.assert.equal(resultString, 'before test subref string after', 'Message ref and subref dereferenced.');
});
test('arrayRemove', function() {
var arr = [1, 2, 3, 2];
assertEquals('Remove Not found', false, Blockly.utils.arrayRemove(arr, 0));
assertEquals('Remove Not found result', '1,2,3,2', arr.join(','));
assertEquals('Remove item', true, Blockly.utils.arrayRemove(arr, 2));
assertEquals('Remove item result', '1,3,2', arr.join(','));
assertEquals('Remove item again', true, Blockly.utils.arrayRemove(arr, 2));
assertEquals('Remove item again result', '1,3', arr.join(','));
chai.assert.isFalse(Blockly.utils.arrayRemove(arr, 0), 'Remove Not found');
chai.assert.equal(arr.join(','), '1,2,3,2', 'Remove Not found result');
chai.assert.isTrue(Blockly.utils.arrayRemove(arr, 2), 'Remove item');
chai.assert.equal(arr.join(','), '1,3,2', 'Remove item result');
chai.assert.isTrue(Blockly.utils.arrayRemove(arr, 2), 'Remove item again');
chai.assert.equal(arr.join(','), '1,3', 'Remove item again result');
});
test('XY_REGEX_', function() {
var regex = Blockly.utils.getRelativeXY.XY_REGEX_;
var m;
m = 'INVALID'.match(regex);
assertNull(m);
chai.assert.isNull(m);
m = 'translate(10)'.match(regex);
assertEquals('translate(10), x', '10', m[1]);
assertUndefined('translate(10), y', m[3]);
chai.assert.equal(m[1], '10', 'translate(10), x');
chai.assert.isUndefined(m[3], 'translate(10), y');
m = 'translate(11, 12)'.match(regex);
assertEquals('translate(11, 12), x', '11', m[1]);
assertEquals('translate(11, 12), y', '12', m[3]);
chai.assert.equal(m[1], '11', 'translate(11, 12), x');
chai.assert.equal(m[3], '12', 'translate(11, 12), y');
m = 'translate(13,14)'.match(regex);
assertEquals('translate(13,14), x', '13', m[1]);
assertEquals('translate(13,14), y', '14', m[3]);
chai.assert.equal(m[1], '13', 'translate(13,14), x');
chai.assert.equal(m[3], '14', 'translate(13,14), y');
m = 'translate(15 16)'.match(regex);
assertEquals('translate(15 16), x', '15', m[1]);
assertEquals('translate(15 16), y', '16', m[3]);
chai.assert.equal(m[1], '15', 'translate(15 16), x');
chai.assert.equal(m[3], '16', 'translate(15 16), y');
m = 'translate(1.23456e+42 0.123456e-42)'.match(regex);
assertEquals('translate(1.23456e+42 0.123456e-42), x', '1.23456e+42', m[1]);
assertEquals('translate(1.23456e+42 0.123456e-42), y', '0.123456e-42', m[3]);
chai.assert.equal(m[1], '1.23456e+42', 'translate(1.23456e+42 0.123456e-42), x');
chai.assert.equal(m[3], '0.123456e-42', 'translate(1.23456e+42 0.123456e-42), y');
});
test('XY_STYLE_REGEX_', function() {
var regex = Blockly.utils.getRelativeXY.XY_STYLE_REGEX_;
var m;
m = 'INVALID'.match(regex);
assertNull(m);
chai.assert.isNull(m);
m = 'transform:translate(9px)'.match(regex);
assertEquals('transform:translate(9px), x', '9', m[1]);
assertUndefined('transform:translate(9px), y', m[3]);
chai.assert.equal(m[1], '9', 'transform:translate(9px), x');
chai.assert.isUndefined(m[3], 'transform:translate(9px), y');
m = 'transform:translate3d(10px)'.match(regex);
assertEquals('transform:translate3d(10px), x', '10', m[1]);
assertUndefined('transform:translate(10px), y', m[3]);
chai.assert.equal(m[1], '10', 'transform:translate3d(10px), x');
chai.assert.isUndefined(m[3], 'transform:translate(10px), y');
m = 'transform: translate(11px, 12px)'.match(regex);
assertEquals('transform: translate(11px, 12px), x', '11', m[1]);
assertEquals('transform: translate(11px, 12px), y', '12', m[3]);
chai.assert.equal(m[1], '11', 'transform: translate(11px, 12px), x');
chai.assert.equal(m[3], '12', 'transform: translate(11px, 12px), y');
m = 'transform: translate(13px,14px)'.match(regex);
assertEquals('transform: translate(13px,14px), x', '13', m[1]);
assertEquals('transform: translate(13px,14px), y', '14', m[3]);
chai.assert.equal(m[1], '13', 'transform: translate(13px,14px), x');
chai.assert.equal(m[3], '14', 'transform: translate(13px,14px), y');
m = 'transform: translate(15px 16px)'.match(regex);
assertEquals('transform: translate(15px 16px), x', '15', m[1]);
assertEquals('transform: translate(15px 16px), y', '16', m[3]);
chai.assert.equal(m[1], '15', 'transform: translate(15px 16px), x');
chai.assert.equal(m[3], '16', 'transform: translate(15px 16px), y');
m = 'transform: translate(1.23456e+42px 0.123456e-42px)'.match(regex);
assertEquals('transform: translate(1.23456e+42px 0.123456e-42px), x', '1.23456e+42', m[1]);
assertEquals('transform: translate(1.23456e+42px 0.123456e-42px), y', '0.123456e-42', m[3]);
chai.assert.equal(m[1], '1.23456e+42', 'transform: translate(1.23456e+42px 0.123456e-42px), x');
chai.assert.equal(m[3], '0.123456e-42', 'transform: translate(1.23456e+42px 0.123456e-42px), y');
m = 'transform:translate3d(20px, 21px, 22px)'.match(regex);
assertEquals('transform:translate3d(20px, 21px, 22px), x', '20', m[1]);
assertEquals('transform:translate3d(20px, 21px, 22px), y', '21', m[3]);
chai.assert.equal(m[1], '20', 'transform:translate3d(20px, 21px, 22px), x');
chai.assert.equal(m[3], '21', 'transform:translate3d(20px, 21px, 22px), y');
m = 'transform:translate3d(23px,24px,25px)'.match(regex);
assertEquals('transform:translate3d(23px,24px,25px), x', '23', m[1]);
assertEquals('transform:translate3d(23px,24px,25px), y', '24', m[3]);
chai.assert.equal(m[1], '23', 'transform:translate3d(23px,24px,25px), x');
chai.assert.equal(m[3], '24', 'transform:translate3d(23px,24px,25px), y');
m = 'transform:translate3d(26px 27px 28px)'.match(regex);
assertEquals('transform:translate3d(26px 27px 28px), x', '26', m[1]);
assertEquals('transform:translate3d(26px 27px 28px), y', '27', m[3]);
chai.assert.equal(m[1], '26', 'transform:translate3d(26px 27px 28px), x');
chai.assert.equal(m[3], '27', 'transform:translate3d(26px 27px 28px), y');
m = 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px)'.match(regex);
assertEquals('transform:translate3d(1.23456e+42px 0.123456e-42px 42px), x', '1.23456e+42', m[1]);
assertEquals('transform:translate3d(1.23456e+42px 0.123456e-42px 42px), y', '0.123456e-42', m[3]);
chai.assert.equal(m[1], '1.23456e+42', 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px), x');
chai.assert.equal(m[3], '0.123456e-42', 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px), y');
});
suite('DOM', function() {
test('addClass', function() {
var p = document.createElement('p');
Blockly.utils.dom.addClass(p, 'one');
assertEquals('Adding "one"', 'one', p.className);
chai.assert.equal(p.className, 'one', 'Adding "one"');
Blockly.utils.dom.addClass(p, 'one');
assertEquals('Adding duplicate "one"', 'one', p.className);
chai.assert.equal(p.className, 'one', 'Adding duplicate "one"');
Blockly.utils.dom.addClass(p, 'two');
assertEquals('Adding "two"', 'one two', p.className);
chai.assert.equal(p.className, 'one two', 'Adding "two"');
Blockly.utils.dom.addClass(p, 'two');
assertEquals('Adding duplicate "two"', 'one two', p.className);
chai.assert.equal(p.className, 'one two', 'Adding duplicate "two"');
Blockly.utils.dom.addClass(p, 'three');
assertEquals('Adding "three"', 'one two three', p.className);
chai.assert.equal(p.className, 'one two three', 'Adding "three"');
});
test('hasClass', function() {
var p = document.createElement('p');
p.className = ' one three two three ';
assertTrue('Has "one"', Blockly.utils.dom.hasClass(p, 'one'));
assertTrue('Has "two"', Blockly.utils.dom.hasClass(p, 'two'));
assertTrue('Has "three"', Blockly.utils.dom.hasClass(p, 'three'));
assertFalse('Has no "four"', Blockly.utils.dom.hasClass(p, 'four'));
assertFalse('Has no "t"', Blockly.utils.dom.hasClass(p, 't'));
chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'one'), 'Has "one"');
chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'two'), 'Has "two"');
chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'three'), 'Has "three"');
chai.assert.isFalse(Blockly.utils.dom.hasClass(p, 'four'), 'Has no "four"');
chai.assert.isFalse(Blockly.utils.dom.hasClass(p, 't'), 'Has no "t"');
});
test('removeClass', function() {
var p = document.createElement('p');
p.className = ' one three two three ';
Blockly.utils.dom.removeClass(p, 'two');
assertEquals('Removing "two"', 'one three three', p.className);
chai.assert.equal(p.className, 'one three three', 'Removing "two"');
Blockly.utils.dom.removeClass(p, 'four');
assertEquals('Removing "four"', 'one three three', p.className);
chai.assert.equal(p.className, 'one three three', 'Removing "four"');
Blockly.utils.dom.removeClass(p, 'three');
assertEquals('Removing "three"', 'one', p.className);
chai.assert.equal(p.className, 'one', 'Removing "three"');
Blockly.utils.dom.removeClass(p, 'ne');
assertEquals('Removing "ne"', 'one', p.className);
chai.assert.equal(p.className, 'one', 'Removing "ne"');
Blockly.utils.dom.removeClass(p, 'one');
assertEquals('Removing "one"', '', p.className);
chai.assert.equal(p.className, '', 'Removing "one"');
Blockly.utils.dom.removeClass(p, 'zero');
assertEquals('Removing "zero"', '', p.className);
chai.assert.equal(p.className, '', 'Removing "zero"');
});
});
suite('String', function() {
test('starts with', function() {
assertEquals('Does not start with', false, Blockly.utils.string.startsWith('123', '2'));
assertEquals('Start with', true, Blockly.utils.string.startsWith('123', '12'));
assertEquals('Start with empty string 1', true, Blockly.utils.string.startsWith('123', ''));
assertEquals('Start with empty string 2', true, Blockly.utils.string.startsWith('', ''));
chai.assert.isFalse(Blockly.utils.string.startsWith('123', '2'), 'Does not start with');
chai.assert.isTrue(Blockly.utils.string.startsWith('123', '12'), 'Start with');
chai.assert.isTrue(Blockly.utils.string.startsWith('123', ''), 'Start with empty string 1');
chai.assert.isTrue(Blockly.utils.string.startsWith('', ''), 'Start with empty string 12');
});
test('shortest string length', function() {
var len = Blockly.utils.string.shortestStringLength('one,two,three,four,five'.split(','));
assertEquals('Length of "one"', 3, len);
chai.assert.equal(len, 3, 'Length of "one"');
len = Blockly.utils.string.shortestStringLength('one,two,three,four,five,'.split(','));
assertEquals('Length of ""', 0, len);
chai.assert.equal(len, 0, 'Length of ""');
len = Blockly.utils.string.shortestStringLength(['Hello World']);
assertEquals('List of one', 11, len);
chai.assert.equal(len, 11, 'List of one');
len = Blockly.utils.string.shortestStringLength([]);
assertEquals('Empty list', 0, len);
chai.assert.equal(len, 0, 'Empty list');
});
test('comment word prefix', function() {
var len = Blockly.utils.string.commonWordPrefix('one,two,three,four,five'.split(','));
assertEquals('No prefix', 0, len);
chai.assert.equal(len, 0, 'No prefix');
len = Blockly.utils.string.commonWordPrefix('Xone,Xtwo,Xthree,Xfour,Xfive'.split(','));
assertEquals('No word prefix', 0, len);
chai.assert.equal(len, 0, 'No word prefix');
len = Blockly.utils.string.commonWordPrefix('abc de,abc de,abc de,abc de'.split(','));
assertEquals('Full equality', 6, len);
chai.assert.equal(len, 6, 'Full equality');
len = Blockly.utils.string.commonWordPrefix('abc deX,abc deY'.split(','));
assertEquals('One word prefix', 4, len);
chai.assert.equal(len, 4, 'One word prefix');
len = Blockly.utils.string.commonWordPrefix('abc de,abc deY'.split(','));
assertEquals('Overflow no', 4, len);
chai.assert.equal(len, 4, 'Overflow no');
len = Blockly.utils.string.commonWordPrefix('abc de,abc de Y'.split(','));
assertEquals('Overflow yes', 6, len);
chai.assert.equal(len, 6, 'Overflow yes');
len = Blockly.utils.string.commonWordPrefix(['Hello World']);
assertEquals('List of one', 11, len);
chai.assert.equal(len, 11, 'List of one');
len = Blockly.utils.string.commonWordPrefix([]);
assertEquals('Empty list', 0, len);
chai.assert.equal(len, 0, 'Empty list');
len = Blockly.utils.string.commonWordPrefix('turn&nbsp;left,turn&nbsp;right'.split(','));
assertEquals('No prefix due to &amp;nbsp;', 0, len);
chai.assert.equal(len, 0, 'No prefix due to &amp;nbsp;');
len = Blockly.utils.string.commonWordPrefix('turn\u00A0left,turn\u00A0right'.split(','));
assertEquals('No prefix due to \\u00A0', 0, len);
chai.assert.equal(len, 0, 'No prefix due to \\u00A0');
});
test('comment word suffix', function() {
var len = Blockly.utils.string.commonWordSuffix('one,two,three,four,five'.split(','));
assertEquals('No suffix', 0, len);
chai.assert.equal(len, 0, 'No suffix');
len = Blockly.utils.string.commonWordSuffix('oneX,twoX,threeX,fourX,fiveX'.split(','));
assertEquals('No word suffix', 0, len);
chai.assert.equal(len, 0, 'No word suffix');
len = Blockly.utils.string.commonWordSuffix('abc de,abc de,abc de,abc de'.split(','));
assertEquals('Full equality', 6, len);
chai.assert.equal(len, 6, 'Full equality');
len = Blockly.utils.string.commonWordSuffix('Xabc de,Yabc de'.split(','));
assertEquals('One word suffix', 3, len);
chai.assert.equal(len, 3, 'One word suffix');
len = Blockly.utils.string.commonWordSuffix('abc de,Yabc de'.split(','));
assertEquals('Overflow no', 3, len);
chai.assert.equal(len, 3, 'Overflow no');
len = Blockly.utils.string.commonWordSuffix('abc de,Y abc de'.split(','));
assertEquals('Overflow yes', 6, len);
chai.assert.equal(len, 6, 'Overflow yes');
len = Blockly.utils.string.commonWordSuffix(['Hello World']);
assertEquals('List of one', 11, len);
chai.assert.equal(len, 11, 'List of one');
len = Blockly.utils.string.commonWordSuffix([]);
assertEquals('Empty list', 0, len);
chai.assert.equal(len, 0, 'Empty list');
});
});
suite('Math', function() {
test('toRadians', function() {
var quarter = Math.PI / 2;
assertEquals('-90', -quarter, Blockly.utils.math.toRadians(-90));
assertEquals('0', 0, Blockly.utils.math.toRadians(0));
assertEquals('90', quarter, Blockly.utils.math.toRadians(90));
assertEquals('180', 2 * quarter, Blockly.utils.math.toRadians(180));
assertEquals('270', 3 * quarter, Blockly.utils.math.toRadians(270));
assertEquals('360', 4 * quarter, Blockly.utils.math.toRadians(360));
assertEquals('450', 5 * quarter, Blockly.utils.math.toRadians(360 + 90));
chai.assert.equal(Blockly.utils.math.toRadians(-90), -quarter, '-90');
chai.assert.equal(Blockly.utils.math.toRadians(0), 0, '0');
chai.assert.equal(Blockly.utils.math.toRadians(90), quarter, '90');
chai.assert.equal(Blockly.utils.math.toRadians(180), 2 * quarter, '180');
chai.assert.equal(Blockly.utils.math.toRadians(270), 3 * quarter, '270');
chai.assert.equal(Blockly.utils.math.toRadians(360), 4 * quarter, '360');
chai.assert.equal(Blockly.utils.math.toRadians(360 + 90), 5 * quarter, '450');
});
test('toDegrees', function() {
var quarter = Math.PI / 2;
assertEquals('-90', -90, Blockly.utils.math.toDegrees(-quarter));
assertEquals('0', 0, Blockly.utils.math.toDegrees(0));
assertEquals('90', 90, Blockly.utils.math.toDegrees(quarter));
assertEquals('180', 180, Blockly.utils.math.toDegrees(2 * quarter));
assertEquals('270', 270, Blockly.utils.math.toDegrees(3 * quarter));
assertEquals('360', 360, Blockly.utils.math.toDegrees(4 * quarter));
assertEquals('450', 360 + 90, Blockly.utils.math.toDegrees(5 * quarter));
chai.assert.equal(Blockly.utils.math.toDegrees(-quarter), -90, '-90');
chai.assert.equal(Blockly.utils.math.toDegrees(0), 0, '0');
chai.assert.equal(Blockly.utils.math.toDegrees(quarter), 90, '90');
chai.assert.equal(Blockly.utils.math.toDegrees(2 * quarter), 180, '180');
chai.assert.equal(Blockly.utils.math.toDegrees(3 * quarter), 270, '270');
chai.assert.equal(Blockly.utils.math.toDegrees(4 * quarter), 360, '360');
chai.assert.equal(Blockly.utils.math.toDegrees(5 * quarter), 360 + 90, '450');
});
});
});

42
tests/mocha/variables_test.js
View File

@@ -57,18 +57,18 @@ suite('Variables', function() {
createTestVarBlock(this.workspace, '3');
var result = Blockly.Variables.allUsedVarModels(this.workspace);
assertEquals('Expected three variables in the list of used variables',
3, result.length);
chai.assert.equal(result.length, 3,
'Expected three variables in the list of used variables');
});
test('Some unused', function() {
createTestVarBlock(this.workspace, '2');
var result = Blockly.Variables.allUsedVarModels(this.workspace);
assertEquals('Expected one variable in the list of used variables',
1, result.length);
assertEquals('Expected variable with ID 2 in the list of used variables',
'2', result[0].getId());
chai.assert.equal(result.length, 1,
'Expected one variable in the list of used variables');
chai.assert.equal(result[0].getId(), '2',
'Expected variable with ID 2 in the list of used variables');
});
test('Var used twice', function() {
@@ -78,16 +78,16 @@ suite('Variables', function() {
var result = Blockly.Variables.allUsedVarModels(this.workspace);
// Using the same variable multiple times should not change the number of
// elements in the list.
assertEquals('Expected one variable in the list of used variables',
1, result.length);
assertEquals('Expected variable with ID 2 in the list of used variables',
'2', result[0].getId());
chai.assert.equal(result.length, 1,
'Expected one variable in the list of used variables');
chai.assert.equal(result[0].getId(), '2',
'Expected variable with ID 2 in the list of used variables');
});
test('All unused', function() {
var result = Blockly.Variables.allUsedVarModels(this.workspace);
assertEquals('Expected no variables in the list of used variables',
0, result.length);
chai.assert.equal(result.length, 0,
'Expected no variables in the list of used variables');
});
});
@@ -100,9 +100,9 @@ suite('Variables', function() {
var result2 = Blockly.Variables.getVariable(this.workspace, 'id2');
var result3 = Blockly.Variables.getVariable(this.workspace, 'id3');
assertEquals(var1, result1);
assertEquals(var2, result2);
assertEquals(var3, result3);
chai.assert.equal(var1, result1);
chai.assert.equal(var2, result2);
chai.assert.equal(var3, result3);
});
test('By name and type', function() {
@@ -117,9 +117,9 @@ suite('Variables', function() {
Blockly.Variables.getVariable(this.workspace, null, 'name3', 'type2');
// Searching by name + type is correct.
assertEquals(var1, result1);
assertEquals(var2, result2);
assertEquals(var3, result3);
chai.assert.equal(var1, result1);
chai.assert.equal(var2, result2);
chai.assert.equal(var3, result3);
});
test('Bad id with name and type fallback', function() {
@@ -134,9 +134,9 @@ suite('Variables', function() {
Blockly.Variables.getVariable(this.workspace, 'badId', 'name3', 'type2');
// Searching by ID failed, but falling back onto name + type is correct.
assertEquals(var1, result1);
assertEquals(var2, result2);
assertEquals(var3, result3);
chai.assert.equal(var1, result1);
chai.assert.equal(var2, result2);
chai.assert.equal(var3, result3);
});
});
});

63
tests/mocha/xml_test.js
View File

@@ -6,33 +6,26 @@
suite('XML', function() {
var assertSimpleFieldDom = function(fieldDom, name, text) {
assertEquals(text, fieldDom.textContent);
assertEquals(name, fieldDom.getAttribute('name'));
chai.assert.equal(text, fieldDom.textContent);
chai.assert.equal(name, fieldDom.getAttribute('name'));
};
var assertNonSerializingFieldDom = function(fieldDom) {
assertEquals(undefined, fieldDom.childNodes[0]);
chai.assert.isUndefined(fieldDom.childNodes[0]);
};
var assertNonVariableField = function(fieldDom, name, text) {
assertSimpleFieldDom(fieldDom, name, text);
assertNull('id', fieldDom.getAttribute('id'));
assertNull('variabletype', fieldDom.getAttribute('variabletype'));
chai.assert.isNull(fieldDom.getAttribute('id'), 'id');
chai.assert.isNull(fieldDom.getAttribute('variabletype'), 'variabletype');
};
var assertVariableDomField = function(fieldDom, name, type, id, text) {
assertSimpleFieldDom(fieldDom, name, text);
assertEquals(type, fieldDom.getAttribute('variabletype'));
assertEquals(id, fieldDom.getAttribute('id'));
chai.assert.equal(fieldDom.getAttribute('variabletype'), type);
chai.assert.equal(fieldDom.getAttribute('id'), id);
};
var assertVariableDom = function(fieldDom, type, id, text) {
assertEquals(type, fieldDom.getAttribute('type'));
assertEquals(id, fieldDom.getAttribute('id'));
assertEquals(text, fieldDom.textContent);
};
var assertVariableValues = function(container, name, type, id) {
var variable = container.getVariableById(id);
assertNotUndefined(variable);
assertEquals(name, variable.name);
assertEquals(type, variable.type);
assertEquals(id, variable.getId());
chai.assert.equal(fieldDom.getAttribute('type'), type);
chai.assert.equal(fieldDom.getAttribute('id'), id);
chai.assert.equal(fieldDom.textContent, text);
};
setup(function() {
Blockly.defineBlocksWithJsonArray([
@@ -84,8 +77,8 @@ suite('XML', function() {
suite('textToDom', function() {
test('Basic', function() {
var dom = Blockly.Xml.textToDom(this.complexXmlText);
assertEquals('XML tag', 'xml', dom.nodeName);
assertEquals('Block tags', 6, dom.getElementsByTagName('block').length);
chai.assert.equal(dom.nodeName, 'xml', 'XML tag');
chai.assert.equal(dom.getElementsByTagName('block').length, 6, 'Block tags');
});
});
suite('blockToDom', function() {
@@ -442,11 +435,11 @@ suite('XML', function() {
this.workspace.createVariable('name1');
var resultDom =
Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
assertEquals(1, resultDom.children.length);
chai.assert.equal(resultDom.children.length, 1);
var resultVariableDom = resultDom.children[0];
assertEquals('name1', resultVariableDom.textContent);
assertEquals(null, resultVariableDom.getAttribute('type'));
assertEquals('1', resultVariableDom.getAttribute('id'));
chai.assert.equal(resultVariableDom.textContent, 'name1');
chai.assert.isNull(resultVariableDom.getAttribute('type'));
chai.assert.equal(resultVariableDom.getAttribute('id'), '1');
});
test('Two Variable one block', function() {
this.workspace.createVariable('name1', '', 'id1');
@@ -459,7 +452,7 @@ suite('XML', function() {
Blockly.Events.enable();
var resultDom = Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
assertEquals(2, resultDom.children.length);
chai.assert.equal(resultDom.children.length, 2);
assertVariableDom(resultDom.children[0], null, 'id1',
'name1');
assertVariableDom(resultDom.children[1], 'type2', 'id2',
@@ -468,23 +461,23 @@ suite('XML', function() {
test('No variables', function() {
var resultDom =
Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
assertEquals(0, resultDom.children.length);
chai.assert.equal(resultDom.children.length, 0);
});
});
suite('domToText', function() {
test('Round tripping', function() {
var dom = Blockly.Xml.textToDom(this.complexXmlText);
var text = Blockly.Xml.domToText(dom);
assertEquals('Round trip', this.complexXmlText.replace(/\s+/g, ''),
text.replace(/\s+/g, ''));
chai.assert.equal(text.replace(/\s+/g, ''),
this.complexXmlText.replace(/\s+/g, ''), 'Round trip');
});
});
suite('domToPrettyText', function() {
test('Round tripping', function() {
var dom = Blockly.Xml.textToDom(this.complexXmlText);
var text = Blockly.Xml.domToPrettyText(dom);
assertEquals('Round trip', this.complexXmlText.replace(/\s+/g, ''),
text.replace(/\s+/g, ''));
chai.assert.equal(text.replace(/\s+/g, ''),
this.complexXmlText.replace(/\s+/g, ''), 'Round trip');
});
});
suite('domToBlock', function() {
@@ -722,7 +715,7 @@ suite('XML', function() {
' </block>' +
'</xml>');
Blockly.Xml.domToWorkspace(dom, this.workspace);
assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
assertVariableValues(this.workspace, 'name1', '', '1');
});
test('Variables at top', function() {
@@ -738,7 +731,7 @@ suite('XML', function() {
' </block>' +
'</xml>');
Blockly.Xml.domToWorkspace(dom, this.workspace);
assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
assertVariableValues(this.workspace, 'name1', 'type1', 'id1');
assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
assertVariableValues(this.workspace, 'name3', '', 'id3');
@@ -806,10 +799,10 @@ suite('XML', function() {
' </block>' +
'</xml>');
Blockly.Xml.appendDomToWorkspace(dom, this.workspace);
assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
var newBlockIds = Blockly.Xml.appendDomToWorkspace(dom, this.workspace);
assertEquals('Block count', 2, this.workspace.getAllBlocks(false).length);
assertEquals('Number of new block ids', 1, newBlockIds.length);
chai.assert.equal(this.workspace.getAllBlocks(false).length, 2, 'Block count');
chai.assert.equal(newBlockIds.length, 1, 'Number of new block ids');
});
});
suite('workspaceToDom -> domToWorkspace -> workspaceToDom', function() {
@@ -881,7 +874,7 @@ suite('XML', function() {
' id="' + varId + '"' +
' variabletype="' + type + '"' +
'>' + name + '</field>';
assertEquals(expectedXml, generatedXml);
chai.assert.equal(generatedXml, expectedXml);
});
});
});