From 965d322405333eac0b26cd02d48130de54b2e042 Mon Sep 17 00:00:00 2001 From: ElementG9 Date: Sat, 5 Oct 2019 21:41:08 -0600 Subject: [PATCH] Add tests for combineGroups --- test/test.js | 595 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 346 insertions(+), 249 deletions(-) diff --git a/test/test.js b/test/test.js index e1038e4..a1e103d 100644 --- a/test/test.js +++ b/test/test.js @@ -56,253 +56,350 @@ describe('types.js', () => { }); }); describe('tokenizer.js', () => { - it('Has a tokenize child', () => { - assert.equal(tokenizer.hasOwnProperty('tokenize'), true); - }); - it('Has a util child', () => { - assert.equal(tokenizer.hasOwnProperty('util'), true); - }); - describe('util', () => { - it('combineEscapedChars works', () => { - assert.equal(tokenizer.util.combineEscapedChars(`let x = 'test\\nnewline';`.split('')).join(''), `let x = 'test\\nnewline';`); - }); - it('removeComments works', () => { - assert.equal(tokenizer.util.removeComments(`// Comment\nlet i = 0;`.split('')).join(''), `let i = 0;`); - }); - it('changeKeywords works', () => { - let tokens = tokenizer.util.changeKeywords([{ - type: 'name', - subtype: 'variable', - value: 'let' - }, { - type: 'name', - subtype: 'variable', - value: 'x' - }]); - let correct = [{ - type: 'name', - subtype: 'keyword', - value: 'let' - }, { - type: 'name', - subtype: 'variable', - value: 'x' - }]; - let isCorrect = true; - tokens.forEach((t, i) => { - if (t.type != correct[i].type) - throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got \'' + t.type + '\'') - else if (t.subtype != correct[i].subtype) - throw new Error('Incorrectly changed subtype: Expected \'' + correct[i].subtype + '\' but got \'' + t.subtype + '\'') - else if (t.value != correct[i].value) - throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got \'' + t.value + '\'') - }); - }); it('getDelimiterToken works', () => { - let token = tokenizer.util.getDelimiterToken(')'); - if (token.type != 'delimiter') - throw new Error('Incorrect type: Expected \'delimiter\' but got \'' + token.type + '\'') - else if (token.subtype != 'right') - throw new Error('Incorrect subtype: Expected \'right\' but got \'' + token.subtype + '\'') - else if (token.value != 'parenthesis') - throw new Error('Incorrect value: Expected \'parenthesis\' but got \'' + token.value + '\'') - }); it('operatorType works', () => { - assert.equal(tokenizer.util.operatorType('++'), 'left'); - assert.equal(tokenizer.util.operatorType(';'), 'none'); - assert.equal(tokenizer.util.operatorType('+'), 'dual'); - }); it('determineCharType works', () => { - assert.equal(tokenizer.util.determineCharType('+'), 'operator'); - assert.equal(tokenizer.util.determineCharType('"'), 'string delimiter'); - assert.equal(tokenizer.util.determineCharType('4'), 'digit'); - }); it('determineType works', () => { - assert.equal(tokenizer.util.determineType('let'), 'keyword'); - assert.equal(tokenizer.util.determineType('dog'), 'unknown'); - }); - }); - }); describe('parser.js', () => { - it('Has a parse child', () => { - assert.equal(parser.hasOwnProperty('parse'), true); - }); - it('Has a util child', () => { - assert.equal(parser.hasOwnProperty('util'), true); - }); - describe('util', () => { - it('addIndexes works', () => { - let tokens = parser.util.addIndexes([{ - type: 'name', - subtype: 'keyword', - value: 'let' - }, { - type: 'name', - subtype: 'variable', - value: 'x' - }]); - let correct = [{ - type: 'name', - subtype: 'keyword', - value: 'let', - index: 0 - }, { - type: 'name', - subtype: 'variable', - value: 'x', - index: 1 - }]; - let isCorrect = true; - tokens.forEach((t, i) => { - if (t.type != correct[i].type) - throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got ' + t.type) - else if (t.subtype != correct[i].subtype) - throw new Error('Changed subtype: Expected \'' + correct[i].subtype + '\' but got ' + t.subtype) - else if (t.value != correct[i].value) - throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got ' + t.value) - else if (t.index != correct[i].index) - throw new Error('Incorrect index: Expected \'' + correct[i].index + '\' but got ' + t.index) - }); - }); - it('addLevels works', () => { - let tokens = parser.util.addLevels([{ - type: 'name', - subtype: 'keyword', - value: 'let', - index: 0 - }, { - type: 'name', - subtype: 'variable', - value: 'x', - index: 1 - }, { - type: 'operator', - subtype: 'dual', - value: '=', - index: 2 - }, { - type: 'delimiter', - subtype: 'left', - value: 'parenthesis', - index: 3 - }, { - type: 'number', - subtype: 'n/a', - value: '5', - index: 4 - }, { - type: 'delimiter', - subtype: 'right', - value: 'parenthesis', - index: 5 - }]); - let correct = [{ - type: 'name', - subtype: 'keyword', - value: 'let', - index: 0, - level: 0 - }, { - type: 'name', - subtype: 'variable', - value: 'x', - index: 1, - level: 0 - }, { - type: 'operator', - subtype: 'dual', - value: '=', - index: 2, - level: 0 - }, { - type: 'delimiter', - subtype: 'left', - value: 'parenthesis', - index: 3, - level: 1 - }, { - type: 'number', - subtype: 'n/a', - value: '5', - index: 4, - level: 1 - }, { - type: 'delimiter', - subtype: 'right', - value: 'parenthesis', - index: 5, - level: 1 - }]; - let isCorrect = true; - tokens.forEach((t, i) => { - if (t.type != correct[i].type) - throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got ' + t.type) - else if (t.subtype != correct[i].subtype) - throw new Error('Changed subtype: Expected \'' + correct[i].subtype + '\' but got \'' + t.subtype + '\'') - else if (t.value != correct[i].value) - throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got \'' + t.value + '\'') - else if (t.index != correct[i].index) - throw new Error('Incorrect index: Expected \'' + correct[i].index + '\' but got \'' + t.index + '\'') - else if (t.level != correct[i].level) - throw new Error('Incorrect level: Expected \'' + correct[i].level + '\' but got \'' + t.level + '\'') - }); - }); - it('getDeepestLevel works', () => { - let deepestLevel = parser.util.getDeepestLevel([{ - type: 'name', - subtype: 'keyword', - value: 'let', - index: 0, - level: 0 - }, { - type: 'name', - subtype: 'variable', - value: 'x', - index: 1, - level: 0 - - }, { - type: 'operator', - subtype: 'dual', - value: '=', - index: 2, - level: 0 - }, { - type: 'delimiter', - subtype: 'left', - value: 'parenthesis', - index: 3, - level: 1 - }, { - type: 'number', - subtype: 'n/a', - value: '5', - index: 4, - level: 1 - }, { - type: 'operator', - subtype: 'dual', - value: '+', - index: 5, - level: 1 - }, { - type: 'number', - subtype: 'n/a', - value: '3', - index: 6, - level: 1 - }, - { - type: 'delimiter', - subtype: 'right', - value: 'parenthesis', - index: 7, - level: 1 - }, { - type: 'operator', - subtype: 'none', - value: ';', - index: 8, - level: 0 - } - ]); - if (deepestLevel != 1) - throw new Error('Incorrect deepestLevel. Expected \'1\' but got \'' + deepestLevel + '\''); - }); - }); + it('combineEscapedChars works', () => { + assert.equal(tokenizer.util.combineEscapedChars(`let x = 'test\\nnewline';`.split('')).join(''), `let x = 'test\\nnewline';`); + }); + it('removeComments works', () => { + assert.equal(tokenizer.util.removeComments(`// Comment\nlet i = 0;`.split('')).join(''), `let i = 0;`); + }); + it('changeKeywords works', () => { + let tokens = tokenizer.util.changeKeywords([{ + type: 'name', + subtype: 'variable', + value: 'let' + }, { + type: 'name', + subtype: 'variable', + value: 'x' + }]); + let correct = [{ + type: 'name', + subtype: 'keyword', + value: 'let' + }, { + type: 'name', + subtype: 'variable', + value: 'x' + }]; + let isCorrect = true; + tokens.forEach((t, i) => { + if (t.type != correct[i].type) + throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got \'' + t.type + '\'') + else if (t.subtype != correct[i].subtype) + throw new Error('Incorrectly changed subtype: Expected \'' + correct[i].subtype + '\' but got \'' + t.subtype + '\'') + else if (t.value != correct[i].value) + throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got \'' + t.value + '\'') }); + }); + it('getDelimiterToken works', () => { + let token = tokenizer.util.getDelimiterToken(')'); + if (token.type != 'delimiter') + throw new Error('Incorrect type: Expected \'delimiter\' but got \'' + token.type + '\'') + else if (token.subtype != 'right') + throw new Error('Incorrect subtype: Expected \'right\' but got \'' + token.subtype + '\'') + else if (token.value != 'parenthesis') + throw new Error('Incorrect value: Expected \'parenthesis\' but got \'' + token.value + '\'') + }); + it('operatorType works', () => { + assert.equal(tokenizer.util.operatorType('++'), 'left'); + assert.equal(tokenizer.util.operatorType(';'), 'none'); + assert.equal(tokenizer.util.operatorType('+'), 'dual'); + }); + it('determineCharType works', () => { + assert.equal(tokenizer.util.determineCharType('+'), 'operator'); + assert.equal(tokenizer.util.determineCharType('"'), 'string delimiter'); + assert.equal(tokenizer.util.determineCharType('4'), 'digit'); + }); + it('determineType works', () => { + assert.equal(tokenizer.util.determineType('let'), 'keyword'); + assert.equal(tokenizer.util.determineType('dog'), 'unknown'); + }); +}); +describe('parser.js', () => { + it('addIndexes works', () => { + let tokens = parser.util.addIndexes([{ + type: 'name', + subtype: 'keyword', + value: 'let' + }, { + type: 'name', + subtype: 'variable', + value: 'x' + }]); + let correct = [{ + type: 'name', + subtype: 'keyword', + value: 'let', + index: 0 + }, { + type: 'name', + subtype: 'variable', + value: 'x', + index: 1 + }]; + let isCorrect = true; + tokens.forEach((t, i) => { + if (t.type != correct[i].type) + throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got ' + t.type) + else if (t.subtype != correct[i].subtype) + throw new Error('Changed subtype: Expected \'' + correct[i].subtype + '\' but got ' + t.subtype) + else if (t.value != correct[i].value) + throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got ' + t.value) + else if (t.index != correct[i].index) + throw new Error('Incorrect index: Expected \'' + correct[i].index + '\' but got ' + t.index) + }); + }); + it('addLevels works', () => { + let tokens = parser.util.addLevels([{ + type: 'name', + subtype: 'keyword', + value: 'let', + index: 0 + }, { + type: 'name', + subtype: 'variable', + value: 'x', + index: 1 + }, { + type: 'operator', + subtype: 'dual', + value: '=', + index: 2 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 3 + }, { + type: 'number', + subtype: 'n/a', + value: '5', + index: 4 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 5 + }]); + let correct = [{ + type: 'name', + subtype: 'keyword', + value: 'let', + index: 0, + level: 0 + }, { + type: 'name', + subtype: 'variable', + value: 'x', + index: 1, + level: 0 + }, { + type: 'operator', + subtype: 'dual', + value: '=', + index: 2, + level: 0 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 3, + level: 1 + }, { + type: 'number', + subtype: 'n/a', + value: '5', + index: 4, + level: 1 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 5, + level: 1 + }]; + let isCorrect = true; + tokens.forEach((t, i) => { + if (t.type != correct[i].type) + throw new Error('Changed type: Expected \'' + correct[i].type + '\' but got ' + t.type) + else if (t.subtype != correct[i].subtype) + throw new Error('Changed subtype: Expected \'' + correct[i].subtype + '\' but got \'' + t.subtype + '\'') + else if (t.value != correct[i].value) + throw new Error('Changed value: Expected \'' + correct[i].value + '\' but got \'' + t.value + '\'') + else if (t.index != correct[i].index) + throw new Error('Incorrect index: Expected \'' + correct[i].index + '\' but got \'' + t.index + '\'') + else if (t.level != correct[i].level) + throw new Error('Incorrect level: Expected \'' + correct[i].level + '\' but got \'' + t.level + '\'') + }); + }); + it('getDeepestLevel works', () => { + let deepestLevel = parser.util.getDeepestLevel([{ + type: 'name', + subtype: 'keyword', + value: 'let', + index: 0, + level: 0 + }, { + type: 'name', + subtype: 'variable', + value: 'x', + index: 1, + level: 0 + + }, { + type: 'operator', + subtype: 'dual', + value: '=', + index: 2, + level: 0 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 3, + level: 1 + }, { + type: 'number', + subtype: 'n/a', + value: '5', + index: 4, + level: 1 + }, { + type: 'operator', + subtype: 'dual', + value: '+', + index: 5, + level: 1 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 6, + level: 2 + }, { + type: 'number', + subtype: 'n/a', + value: '6', + index: 7, + level: 2 + }, { + type: 'operator', + subtype: 'dual', + value: '*', + index: 8, + level: 2 + }, { + type: 'number', + subtype: 'n/a', + value: '2', + index: 9, + level: 2 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 10, + level: 2 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 11, + level: 1 + }, { + type: 'operator', + subtype: 'none', + value: ';', + index: 12, + level: 0 + }]); + if (deepestLevel != 2) + throw new Error('Incorrect deepestLevel. Expected \'2\' but got \'' + deepestLevel + '\''); + }); + it('combineGroups works', () => { + let ast = parser.util.combineGroups([{ + type: 'name', + subtype: 'keyword', + value: 'let', + index: 0, + level: 0 + }, { + type: 'name', + subtype: 'variable', + value: 'x', + index: 1, + level: 0 + + }, { + type: 'operator', + subtype: 'dual', + value: '=', + index: 2, + level: 0 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 3, + level: 1 + }, { + type: 'number', + subtype: 'n/a', + value: '5', + index: 4, + level: 1 + }, { + type: 'operator', + subtype: 'dual', + value: '+', + index: 5, + level: 1 + }, { + type: 'delimiter', + subtype: 'left', + value: 'parenthesis', + index: 6, + level: 2 + }, { + type: 'number', + subtype: 'n/a', + value: '6', + index: 7, + level: 2 + }, { + type: 'operator', + subtype: 'dual', + value: '*', + index: 8, + level: 2 + }, { + type: 'number', + subtype: 'n/a', + value: '2', + index: 9, + level: 2 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 10, + level: 2 + }, { + type: 'delimiter', + subtype: 'right', + value: 'parenthesis', + index: 11, + level: 1 + }, { + type: 'operator', + subtype: 'none', + value: ';', + index: 12, + level: 0 + }]); + if (ast[3].type != 'group') + throw new Error('Incorrectly combined group.'); + if (ast[3].tokens[3].type != 'group') + throw new Error('Incorrectly combined group.'); + }); +});