mirror of
https://github.com/joelwmale/webhook-action.git
synced 2024-12-01 20:05:21 +01:00
334 lines
10 KiB
JavaScript
334 lines
10 KiB
JavaScript
var _ = require('lodash');
|
|
var seedrandom = require('seedrandom');
|
|
var diff = require('./diff.js');
|
|
|
|
var ITERATIONS = 10000;
|
|
var ALPHABET = 'GATTACA';
|
|
var LENGTH = 100;
|
|
var EMOJI_MAX_LENGTH = 50;
|
|
|
|
var seed = Math.floor(Math.random() * 10000);
|
|
var random = seedrandom(seed);
|
|
|
|
console.log('Running regression tests...');
|
|
[
|
|
['GAATAAAAAAAGATTAACAT', 'AAAAACTTGTAATTAACAAC'],
|
|
['🔘🤘🔗🔗', '🔗🤗🤗__🤗🤘🤘🤗🔗🤘🔗'],
|
|
['🔗🤗🤗__🤗🤘🤘🤗🔗🤘🔗', '🤗🤘🔘'],
|
|
['🤘🤘🔘🔘_🔘🔗🤘🤗🤗__🔗🤘', '🤘🔘🤘🔗🤘🤘🔗🤗🤘🔘🔘'],
|
|
['🤗🤘🤗🔘🤘🔘🤗_🤗🔗🤘🤗_🤘🔗🤗🤘🔗🤘🤘🤘🔗🤗🔗🔗🔗🤗_🤘🔗🤗🤗🔘🤗🤗🤘🤗',
|
|
'_🤗🤘_🤘🤘🔘🤗🔘🤘_🔘🤗🔗🔘🔗🤘🔗🤘🤗🔗🔗🔗🤘🔘_🤗🤘🤘🤘__🤘_🔘🤘🤘_🔗🤘🔘'],
|
|
['🔗🤘🤗🔘🔘🤗', '🤘🤘🤘🤗🔘🔗🔗'],
|
|
['🔘_🔗🔗🔗🤗🔗', '🤘🤗🔗🤗_🤘🔘_'],
|
|
].forEach(function (data) {
|
|
var result = diff(data[0], data[1]);
|
|
applyDiff(result, data[0], data[1]);
|
|
});
|
|
|
|
console.log('Running computing ' + ITERATIONS + ' diffs with seed ' + seed + '...');
|
|
|
|
console.log('Generating strings...');
|
|
var strings = [];
|
|
for (var i = 0; i <= ITERATIONS; ++i) {
|
|
var chars = [];
|
|
for (var l = 0; l < LENGTH; ++l) {
|
|
var letter = ALPHABET.substr(Math.floor(random() * ALPHABET.length), 1);
|
|
chars.push(letter);
|
|
}
|
|
strings.push(chars.join(''));
|
|
}
|
|
|
|
console.log('Running fuzz tests *without* cursor information...');
|
|
for (var i = 0; i < ITERATIONS; ++i) {
|
|
var result = diff(strings[i], strings[i + 1]);
|
|
applyDiff(result, strings[i], strings[i + 1]);
|
|
}
|
|
|
|
console.log('Running fuzz tests *with* cursor information');
|
|
for (var i = 0; i < ITERATIONS; ++i) {
|
|
var cursor_pos = Math.floor(random() * strings[i].length + 1);
|
|
var diffs = diff(strings[i], strings[i + 1], cursor_pos);
|
|
applyDiff(diffs, strings[i], strings[i + 1]);
|
|
}
|
|
|
|
function parseDiff(str) {
|
|
if (!str) {
|
|
return [];
|
|
}
|
|
return str.split(/(?=[+\-=])/).map(function (piece) {
|
|
var symbol = piece.charAt(0);
|
|
var text = piece.slice(1);
|
|
return [
|
|
symbol === '+' ? diff.INSERT : symbol === '-' ? diff.DELETE : diff.EQUAL,
|
|
text
|
|
]
|
|
});
|
|
}
|
|
|
|
console.log('Running cursor tests');
|
|
[
|
|
['', 0, '', null, ''],
|
|
|
|
['', 0, 'a', null, '+a'],
|
|
['a', 0, 'aa', null, '+a=a'],
|
|
['a', 1, 'aa', null, '=a+a'],
|
|
['aa', 0, 'aaa', null, '+a=aa'],
|
|
['aa', 1, 'aaa', null, '=a+a=a'],
|
|
['aa', 2, 'aaa', null, '=aa+a'],
|
|
['aaa', 0, 'aaaa', null, '+a=aaa'],
|
|
['aaa', 1, 'aaaa', null, '=a+a=aa'],
|
|
['aaa', 2, 'aaaa', null, '=aa+a=a'],
|
|
['aaa', 3, 'aaaa', null, '=aaa+a'],
|
|
|
|
['a', 0, '', null, '-a'],
|
|
['a', 1, '', null, '-a'],
|
|
['aa', 0, 'a', null, '-a=a'],
|
|
['aa', 1, 'a', null, '-a=a'],
|
|
['aa', 2, 'a', null, '=a-a'],
|
|
['aaa', 0, 'aa', null, '-a=aa'],
|
|
['aaa', 1, 'aa', null, '-a=aa'],
|
|
['aaa', 2, 'aa', null, '=a-a=a'],
|
|
['aaa', 3, 'aa', null, '=aa-a'],
|
|
|
|
['', 0, '', 0, ''],
|
|
|
|
['', 0, 'a', 1, '+a'],
|
|
['a', 0, 'aa', 1, '+a=a'],
|
|
['a', 1, 'aa', 2, '=a+a'],
|
|
['aa', 0, 'aaa', 1, '+a=aa'],
|
|
['aa', 1, 'aaa', 2, '=a+a=a'],
|
|
['aa', 2, 'aaa', 3, '=aa+a'],
|
|
['aaa', 0, 'aaaa', 1, '+a=aaa'],
|
|
['aaa', 1, 'aaaa', 2, '=a+a=aa'],
|
|
['aaa', 2, 'aaaa', 3, '=aa+a=a'],
|
|
['aaa', 3, 'aaaa', 4, '=aaa+a'],
|
|
|
|
['a', 1, '', 0, '-a'],
|
|
['aa', 1, 'a', 0, '-a=a'],
|
|
['aa', 2, 'a', 1, '=a-a'],
|
|
['aaa', 1, 'aa', 0, '-a=aa'],
|
|
['aaa', 2, 'aa', 1, '=a-a=a'],
|
|
['aaa', 3, 'aa', 2, '=aa-a'],
|
|
|
|
['a', 1, '', 0, '-a'],
|
|
['aa', 1, 'a', 0, '-a=a'],
|
|
['aa', 2, 'a', 1, '=a-a'],
|
|
['aaa', 1, 'aa', 0, '-a=aa'],
|
|
['aaa', 2, 'aa', 1, '=a-a=a'],
|
|
['aaa', 3, 'aa', 2, '=aa-a'],
|
|
|
|
// forward-delete
|
|
['a', 0, '', 0, '-a'],
|
|
['aa', 0, 'a', 0, '-a=a'],
|
|
['aa', 1, 'a', 1, '=a-a'],
|
|
['aaa', 0, 'aa', 0, '-a=aa'],
|
|
['aaa', 1, 'aa', 1, '=a-a=a'],
|
|
['aaa', 2, 'aa', 2, '=aa-a'],
|
|
|
|
['bob', 0, 'bobob', null, '+bo=bob'],
|
|
['bob', 1, 'bobob', null, '=b+ob=ob'],
|
|
['bob', 2, 'bobob', null, '=bo+bo=b'],
|
|
['bob', 3, 'bobob', null, '=bob+ob'],
|
|
['bob', 0, 'bobob', 2, '+bo=bob'],
|
|
['bob', 1, 'bobob', 3, '=b+ob=ob'],
|
|
['bob', 2, 'bobob', 4, '=bo+bo=b'],
|
|
['bob', 3, 'bobob', 5, '=bob+ob'],
|
|
['bobob', 2, 'bob', null, '-bo=bob'],
|
|
['bobob', 3, 'bob', null, '=b-ob=ob'],
|
|
['bobob', 4, 'bob', null, '=bo-bo=b'],
|
|
['bobob', 5, 'bob', null, '=bob-ob'],
|
|
['bobob', 2, 'bob', 0, '-bo=bob'],
|
|
['bobob', 3, 'bob', 1, '=b-ob=ob'],
|
|
['bobob', 4, 'bob', 2, '=bo-bo=b'],
|
|
['bobob', 5, 'bob', 3, '=bob-ob'],
|
|
|
|
['bob', 1, 'b', null, '=b-ob'],
|
|
|
|
['hello', [0, 5], 'h', 1, '-hello+h'],
|
|
['yay', [0, 3], 'y', 1, '-yay+y'],
|
|
['bobob', [1, 4], 'bob', 2, '=b-obo+o=b'],
|
|
|
|
].forEach(function (data) {
|
|
var oldText = data[0];
|
|
var newText = data[2];
|
|
var oldRange = typeof data[1] === 'number' ?
|
|
{ index: data[1], length: 0 } :
|
|
{ index: data[1][0], length: data[1][1] - data[1][0] };
|
|
var newRange = typeof data[3] === 'number' ?
|
|
{ index: data[3], length: 0 } :
|
|
data[3] === null ? null : { index: data[3][0], length: data[3][1] - data[3][0] };
|
|
var expected = parseDiff(data[4]);
|
|
if (newRange === null && typeof data[1] !== 'number') {
|
|
throw new Error('invalid test case');
|
|
}
|
|
var cursorInfo = newRange === null ? data[1] : {
|
|
oldRange: oldRange,
|
|
newRange: newRange,
|
|
};
|
|
doCursorTest(oldText, newText, cursorInfo, expected);
|
|
doCursorTest('x' + oldText, 'x' + newText, shiftCursorInfo(cursorInfo, 1), diffPrepend(expected, 'x'));
|
|
doCursorTest(oldText + 'x', newText + 'x', cursorInfo, diffAppend(expected, 'x'));
|
|
});
|
|
|
|
function diffPrepend(tuples, text) {
|
|
if (tuples.length > 0 && tuples[0][0] === diff.EQUAL) {
|
|
return [[diff.EQUAL, text + tuples[0][1]]].concat(tuples.slice(1));
|
|
} else {
|
|
return [[diff.EQUAL, text]].concat(tuples);
|
|
}
|
|
}
|
|
|
|
function diffAppend(tuples, text) {
|
|
var lastTuple = tuples[tuples.length - 1];
|
|
if (lastTuple && lastTuple[0] === diff.EQUAL) {
|
|
return tuples.slice(0, -1).concat([[diff.EQUAL, lastTuple[1] + text]]);
|
|
} else {
|
|
return tuples.concat([[diff.EQUAL, text]]);
|
|
}
|
|
}
|
|
|
|
function shiftCursorInfo(cursorInfo, amount) {
|
|
if (typeof cursorInfo === 'number') {
|
|
return cursorInfo + amount;
|
|
} else {
|
|
return {
|
|
oldRange: {
|
|
index: cursorInfo.oldRange.index + amount,
|
|
length: cursorInfo.oldRange.length,
|
|
},
|
|
newRange: {
|
|
index: cursorInfo.newRange.index + amount,
|
|
length: cursorInfo.newRange.length,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
function doCursorTest(oldText, newText, cursorInfo, expected) {
|
|
var result = diff(oldText, newText, cursorInfo);
|
|
if (!_.isEqual(result, expected)) {
|
|
console.log([oldText, newText, cursorInfo]);
|
|
console.log(result, '!==', expected);
|
|
throw new Error('cursor test failed');
|
|
}
|
|
}
|
|
|
|
console.log('Running emoji tests');
|
|
[
|
|
['🐶', '🐯', '-🐶+🐯'],
|
|
['👨🏽', '👩🏽', '-👨+👩=🏽'],
|
|
['👩🏼', '👩🏽', '=👩-🏼+🏽'],
|
|
|
|
['🍏🍎', '🍎', '-🍏=🍎'],
|
|
['🍎', '🍏🍎', '+🍏=🍎'],
|
|
|
|
].forEach(function (data) {
|
|
var oldText = data[0];
|
|
var newText = data[1];
|
|
var expected = parseDiff(data[2]);
|
|
doEmojiTest(oldText, newText, expected);
|
|
doEmojiTest('x' + oldText, 'x' + newText, diffPrepend(expected, 'x'));
|
|
doEmojiTest(oldText + 'x', newText + 'x', diffAppend(expected, 'x'));
|
|
});
|
|
|
|
function doEmojiTest(oldText, newText, expected) {
|
|
var result = diff(oldText, newText);
|
|
if (!_.isEqual(result, expected)) {
|
|
console.log(oldText, newText, expected);
|
|
console.log(result, '!==', expected);
|
|
throw new Error('Emoji simple test case failed');
|
|
}
|
|
}
|
|
|
|
// emojis chosen to share high and low surrogates!
|
|
var EMOJI_ALPHABET = ['_', '🤗', '🔗', '🤘', '🔘'];
|
|
|
|
console.log('Generating emoji strings...');
|
|
var emoji_strings = [];
|
|
for (var i = 0; i <= ITERATIONS; ++i) {
|
|
var letters = [];
|
|
var len = Math.floor(random() * EMOJI_MAX_LENGTH);
|
|
for (var l = 0; l < len; ++l) {
|
|
var letter = EMOJI_ALPHABET[Math.floor(random() * EMOJI_ALPHABET.length)];
|
|
letters.push(letter);
|
|
}
|
|
emoji_strings.push(letters.join(''));
|
|
}
|
|
|
|
console.log('Running emoji fuzz tests...');
|
|
for (var i = 0; i < ITERATIONS; ++i) {
|
|
var oldText = emoji_strings[i];
|
|
var newText = emoji_strings[i + 1];
|
|
var result = diff(oldText, newText);
|
|
applyDiff(result, oldText, newText);
|
|
}
|
|
|
|
// Applies a diff to text, throwing an error if diff is invalid or incorrect
|
|
function applyDiff(diffs, text, expectedResult) {
|
|
var pos = 0;
|
|
function throwError(message) {
|
|
console.log(diffs, text, expectedResult);
|
|
throw new Error(message);
|
|
}
|
|
function expect(expected) {
|
|
var found = text.substr(pos, expected.length);
|
|
if (found !== expected) {
|
|
throwError('Expected "' + expected + '", found "' + found + '"');
|
|
}
|
|
}
|
|
var result = '';
|
|
var inserts_since_last_equality = 0;
|
|
var deletes_since_last_equality = 0;
|
|
for (var i = 0; i < diffs.length; i++) {
|
|
var d = diffs[i];
|
|
if (!d[1]) {
|
|
throwError('Empty tuple in diff')
|
|
}
|
|
var firstCharCode = d[1].charCodeAt(0);
|
|
var lastCharCode = d[1].slice(-1).charCodeAt(0);
|
|
if (firstCharCode >= 0xDC00 && firstCharCode <= 0xDFFF ||
|
|
lastCharCode >= 0xD800 && lastCharCode <= 0xDBFF) {
|
|
throwError('Bad unicode diff tuple')
|
|
}
|
|
switch (d[0]) {
|
|
case diff.EQUAL:
|
|
if (i !== 0 && !inserts_since_last_equality && !deletes_since_last_equality) {
|
|
throwError('two consecutive equalities in diff');
|
|
}
|
|
inserts_since_last_equality = 0;
|
|
deletes_since_last_equality = 0;
|
|
expect(d[1]);
|
|
result += d[1];
|
|
pos += d[1].length;
|
|
break;
|
|
case diff.DELETE:
|
|
if (deletes_since_last_equality) {
|
|
throwError('multiple deletes between equalities')
|
|
}
|
|
if (inserts_since_last_equality) {
|
|
throwError('delete following insert in diff')
|
|
}
|
|
deletes_since_last_equality++;
|
|
expect(d[1]);
|
|
pos += d[1].length;
|
|
break
|
|
case diff.INSERT:
|
|
if (inserts_since_last_equality) {
|
|
throwError('multiple inserts between equalities')
|
|
}
|
|
inserts_since_last_equality++;
|
|
result += d[1];
|
|
break;
|
|
}
|
|
}
|
|
if (pos !== text.length) {
|
|
throwError('Diff did not consume entire input text');
|
|
}
|
|
if (result !== expectedResult) {
|
|
console.log(diffs, text, expectedResult, result);
|
|
throw new Error('Diff not correct')
|
|
}
|
|
return result;
|
|
}
|
|
|
|
console.log("Success!");
|