You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
492 lines
14 KiB
JavaScript
492 lines
14 KiB
JavaScript
/*global console, test, throws, equal, fail, notEqual, expect, require, ok,
|
|
QUnit, RiTa, RiString, RiGrammar, RiMarkov, RiLexicon */
|
|
|
|
var runtests = function() {
|
|
|
|
// only check this for local tests
|
|
var allowLocalWebServer = typeof process != 'undefined'
|
|
&& (!process.env.CI && process.env.ALLOW_URL_TESTS);
|
|
|
|
RiTa.SILENT = 1;
|
|
|
|
var filePath = (typeof module != 'undefined' && module.exports) ? "./test/html/data/" : "./data/"
|
|
|
|
QUnit.module("UrlLoading", {
|
|
|
|
setup: function() {},
|
|
teardown: function() {}
|
|
});
|
|
|
|
asyncTest("RiTa.loadString1(file)", function() {
|
|
|
|
RiTa.loadString(filePath + "sentence1.json", function(s) {
|
|
ok(s && s.length > 100);
|
|
//console.log(s);
|
|
ok(JSON.parse(s));
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.loadString2(file)", function() {
|
|
|
|
RiTa.loadString(filePath + "sentence2.json", function(s) {
|
|
ok(s && s.length > 100);
|
|
ok(JSON.parse(s));
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.loadStrings1(file)", function() {
|
|
|
|
RiTa.loadStrings(filePath + "sentence1.json", function(s) {
|
|
ok(s && s.length > 1);
|
|
//console.log(s);
|
|
ok(JSON.parse(s.join('\n')));
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.loadStrings2(file)", function() {
|
|
|
|
RiTa.loadStrings(filePath + "sentence2.json", function(s) {
|
|
ok(s && s.length > 1);
|
|
ok(JSON.parse(s.join('\n')));
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.testLoadConcordance", function () { // SLOW
|
|
|
|
RiTa.loadString(filePath + "kafka.txt", function (txt) {
|
|
|
|
// test with all false
|
|
var args = {
|
|
ignoreCase: false,
|
|
ignorePunctuation: false,
|
|
ignoreStopWords: false
|
|
}
|
|
data = RiTa.concordance(txt, args);
|
|
ok(data["Gregor"] == 199);
|
|
ok(data["Gregor"] + data["Gregor's"] == 298);
|
|
ok(data["sister"] == 96);
|
|
ok(data["sister"] + data["sister's"] == 101);
|
|
ok(data["here"] == 19);
|
|
ok(data["the"] == 1097);
|
|
ok(data["The"] == 51);
|
|
ok(data[","] == 1292);
|
|
ok(data["."] == 737);
|
|
|
|
|
|
// test all true
|
|
var nUppercaseFather = data["Father"];
|
|
var nLowercaseFather = data["father"];
|
|
args.ignoreCase = true;
|
|
args.ignorePunctuation = true;
|
|
args.ignoreStopWords = true;
|
|
data = RiTa.concordance(txt, args);
|
|
ok(data["gregor"] + data["gregor's"] == 298);
|
|
ok(data["sister"] + data["sister's"] == 101);
|
|
equal(data["here"], null);
|
|
equal(data["the"], null);
|
|
equal(data[","], null);
|
|
equal(data["."], null);
|
|
ok(data["father"] == nUppercaseFather + nLowercaseFather);
|
|
|
|
// test ignoreCase
|
|
args.ignoreCase = true;
|
|
args.ignorePunctuation = false;
|
|
args.ignoreStopWords = false;
|
|
data = RiTa.concordance(txt, args);
|
|
ok(data["father"] == nUppercaseFather + nLowercaseFather);
|
|
|
|
// test ignorePunctuation
|
|
args.ignoreCase = false;
|
|
args.ignorePunctuation = true;
|
|
args.ignoreStopWords = false;
|
|
data = RiTa.concordance(txt, args);
|
|
equal(data[","], null);
|
|
equal(data["."], null);
|
|
|
|
// test ignoreStopWords
|
|
args.ignoreCase = false;
|
|
args.ignorePunctuation = false;
|
|
args.ignoreStopWords = true;
|
|
data = RiTa.concordance(txt, args);
|
|
equal(data["here"], null);
|
|
equal(data["the"], null);
|
|
|
|
// test ignoreStopWords and ignorePunctuation
|
|
args.ignoreCase = false;
|
|
args.ignorePunctuation = true;
|
|
args.ignoreStopWords = true;
|
|
data = RiTa.concordance(txt, args);
|
|
equal(data[","], null);
|
|
equal(data["."], null);
|
|
equal(data["here"], null);
|
|
equal(data["the"], null);
|
|
|
|
// test ignoreStopWords and ignoreCase
|
|
args.ignoreCase = true;
|
|
args.ignorePunctuation = false;
|
|
args.ignoreStopWords = true;
|
|
data = RiTa.concordance(txt, args);
|
|
ok(data["father"] == nUppercaseFather + nLowercaseFather);
|
|
equal(data["here"], null);
|
|
equal(data["the"], null);
|
|
|
|
// test ignorePunctuation and ignoreCase
|
|
args.ignoreCase = true;
|
|
args.ignorePunctuation = true;
|
|
args.ignoreStopWords = false;
|
|
data = RiTa.concordance(txt, args);
|
|
ok(data["father"] == nUppercaseFather + nLowercaseFather);
|
|
equal(data[","], null);
|
|
equal(data["."], null);
|
|
|
|
// test wordsToIgnore
|
|
args.wordsToIgnore = ["father", "sister"];
|
|
args.ignoreCase = false;
|
|
args.ignorePunctuation = false;
|
|
args.ignoreStopWords = false;
|
|
data = RiTa.concordance(txt, args);
|
|
equal(data["father"], null);
|
|
equal(data["sister"], null);
|
|
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.testLoadKwicModel", function () {
|
|
|
|
RiTa.loadString(filePath + "kafka.txt", function (txt) {
|
|
|
|
var args = {
|
|
ignoreCase: false,
|
|
ignorePunctuation: false,
|
|
ignoreStopWords: false
|
|
}
|
|
|
|
// test ignorePunctuation
|
|
args.ignorePunctuation = false;
|
|
lines = RiTa.kwic(txt, ",", args);
|
|
equal(lines.length, 1091);
|
|
args.ignorePunctuation = true;
|
|
lines = RiTa.kwic(txt, ",", args);
|
|
equal(lines.length, 0);
|
|
|
|
// test ignoreCase
|
|
args.wordCount = 4;
|
|
args.ignoreCase = true;
|
|
lines = RiTa.kwic(txt, "eventually", args);
|
|
equal(lines.length, 2);
|
|
args.ignoreCase = false;
|
|
lines = RiTa.kwic(txt, "eventually", args);
|
|
equal(lines.length, 1);
|
|
|
|
// test ignoreStopWords
|
|
lines = RiTa.kwic(txt, "here", args);
|
|
equal(lines.length, 19);
|
|
args.ignoreStopWords = true;
|
|
lines = RiTa.kwic(txt, "here", args);
|
|
equal(lines.length, 0);
|
|
|
|
// test wordCount
|
|
args.wordCount = 6;
|
|
args.ignoreCase = false;
|
|
lines = RiTa.kwic(txt, "sister", args);
|
|
for (var i = 0; i < lines.length; i++) {
|
|
var length = RiTa.tokenize(lines[i]).length;
|
|
equal(length, 6 + 1 + 6);
|
|
}
|
|
|
|
// test wordsToIgnore
|
|
args.wordsToIgnore = ["father", "sister"];
|
|
lines = RiTa.kwic(txt, "father", args);
|
|
equal(lines.length, 0);
|
|
lines = RiTa.kwic(txt, "sister", args);
|
|
equal(lines.length, 0);
|
|
|
|
// test against issue #169
|
|
args.wordCount = 6;
|
|
lines = RiTa.kwic(txt, "door", args);
|
|
equal(lines.length, 86);
|
|
|
|
start();
|
|
});
|
|
});
|
|
|
|
// RiGrammar
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var sentenceGrammar = {
|
|
"<start>" : "<noun_phrase> <verb_phrase>.",
|
|
"<noun_phrase>" : "<determiner> <noun>",
|
|
"<verb_phrase>" : "<verb> | <verb> <noun_phrase> [0.1]",
|
|
"<determiner>" : "a [0.1] | the",
|
|
"<noun>" : "woman | man",
|
|
"<verb>" : "shoots"
|
|
};
|
|
|
|
var sentenceGrammar2 = {
|
|
"<start>" : "<noun_phrase> <verb_phrase>.",
|
|
"<noun_phrase>" : "<determiner> <noun>",
|
|
"<determiner>" : [ "a [0.1]", "the" ],
|
|
"<verb_phrase>" : [ "<verb> <noun_phrase> [0.1]", "<verb>" ],
|
|
"<noun>" : ["woman", "man"],
|
|
"<verb>" : "shoots"
|
|
};
|
|
|
|
asyncTest("RiGrammar.loadFrom(file)", function() {
|
|
|
|
var rg1 = new RiGrammar();
|
|
rg1.loadFrom(filePath + "sentence1.json");
|
|
|
|
var rg2 = RiGrammar(JSON.stringify(sentenceGrammar));
|
|
var rg3 = RiGrammar(JSON.stringify(sentenceGrammar2));
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rg1.ready()) {
|
|
|
|
ok(rg1);
|
|
deepEqual(rg1, rg2);
|
|
deepEqual(rg1, rg3);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
else {
|
|
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
asyncTest("RiGrammar.loadFrom2(file)", function() {
|
|
|
|
var rg1 = new RiGrammar();
|
|
rg1.loadFrom(filePath + "sentence2.json");
|
|
var rg2 = RiGrammar(JSON.stringify(sentenceGrammar));
|
|
var rg3 = RiGrammar(JSON.stringify(sentenceGrammar2));
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rg1.ready()) {
|
|
|
|
ok(rg1);
|
|
deepEqual(rg1, rg2);
|
|
deepEqual(rg1, rg3);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
else {
|
|
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
asyncTest("RiGrammar.loadFrom3(file)", function() {
|
|
|
|
var rg1 = new RiGrammar();
|
|
rg1.loadFrom(filePath + "sentence1.yaml");
|
|
|
|
var rg2 = RiGrammar(JSON.stringify(sentenceGrammar));
|
|
var rg3 = RiGrammar(JSON.stringify(sentenceGrammar2));
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rg1.ready()) {
|
|
|
|
ok(rg1);
|
|
deepEqual(rg1, rg2);
|
|
deepEqual(rg1, rg3);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
else {
|
|
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
asyncTest("RiGrammar.loadFrom4(file)", function() {
|
|
|
|
var rg1 = new RiGrammar();
|
|
rg1.loadFrom(filePath + "sentence2.yaml");
|
|
var rg2 = RiGrammar(JSON.stringify(sentenceGrammar));
|
|
var rg3 = RiGrammar(JSON.stringify(sentenceGrammar2));
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rg1.ready()) {
|
|
|
|
ok(rg1);
|
|
deepEqual(rg1, rg2);
|
|
deepEqual(rg1, rg3);
|
|
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
else {
|
|
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
// RiMarkov
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
asyncTest("RiMarkov.loadFromFile", function() {
|
|
|
|
var rm = new RiMarkov(2);
|
|
rm.loadFrom(filePath + "kafka.txt");
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rm.ready()) {
|
|
|
|
ok(rm.size());
|
|
// TODO: 1 or 2 more better tests here
|
|
|
|
clearInterval(id);
|
|
start();
|
|
|
|
} else {
|
|
|
|
//console.log("waiting...");
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
// SOME TESTS ON THE LOCAL WEBSERVER -- ignore unless allowLocalWebServer set at top
|
|
if (allowLocalWebServer) {
|
|
|
|
var serverPath = "http://localhost/ritajs/test/html/data/";
|
|
|
|
asyncTest("RiTa.loadString1(url)", function() {
|
|
|
|
RiTa.loadString(serverPath+"sentence1.json", function(s) {
|
|
|
|
ok(s && s.length > 100);
|
|
//console.log("JSON:",s);
|
|
ok(JSON.parse(s));
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiTa.loadString2(url)", function() {
|
|
|
|
RiTa.loadString(serverPath+"kafka.txt", function(s) {
|
|
ok(s && s.length > 65536);
|
|
start();
|
|
});
|
|
});
|
|
|
|
asyncTest("RiGrammar.loadFrom(Url)", function() {
|
|
|
|
var grammar = new RiGrammar();
|
|
grammar.loadFrom(serverPath+"/haikuGrammar.json");
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
if (grammar.ready()) {
|
|
ok(grammar);
|
|
start();
|
|
clearInterval(id);
|
|
} else {
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
|
|
}, 50);
|
|
});
|
|
|
|
asyncTest("RiMarkov.loadFromUrl", function() { // SLOW
|
|
|
|
var rm = new RiMarkov(3);
|
|
rm.loadFrom(serverPath+"kafka.txt");
|
|
|
|
var ts = +new Date();
|
|
var id = setInterval(function() {
|
|
|
|
if (rm.ready()) {
|
|
//console.log("RiMarkov.loadFromUrl: "+rm.size());
|
|
ok(rm.size());
|
|
var s = rm.generateSentence();
|
|
//console.log("RiMarkov.loadFromUrl: "+s);
|
|
ok(s);
|
|
|
|
// TODO: 2 more better tests here
|
|
clearInterval(id);
|
|
start();
|
|
|
|
} else {
|
|
|
|
var now = +new Date();
|
|
if (now - ts > 5000) {
|
|
equal("no result", 0);
|
|
start();
|
|
clearInterval(id);
|
|
}
|
|
}
|
|
}, 50);
|
|
});
|
|
}
|
|
else {
|
|
console.log("[INFO] UrlLoading: skipping webserver tests");
|
|
}
|
|
|
|
}// end runtests
|
|
|
|
if (typeof exports != 'undefined') {
|
|
try {
|
|
YAML = require('yamljs');
|
|
}
|
|
catch(e) {
|
|
console.log("[WARN] require() didn't find a YAML parser");
|
|
}
|
|
runtests();
|
|
}
|