1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
// large checks stream partial diagnostics, and a check is dropped when newer input is already waiting.
// usage: node tests/drivers/stream_test.js path/to/zclsp
const assert = require('assert');
const cp = require('child_process');
const server = process.argv[2];
const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
const doc = (n, tail) => { let t = ''; for (let i = 0; i < n; i++) t += `int f${i}(int a) { return a + ${i}; }\n`; return t + tail; };
function messages(out) {
const res = [];
let d = out;
while (d.length) {
const e = d.indexOf('\r\n\r\n'), n = Number(/Content-Length:\s*(\d+)/i.exec(d.subarray(0, e).toString())[1]);
res.push(JSON.parse(d.subarray(e + 4, e + 4 + n))); d = d.subarray(e + 4 + n);
}
return res;
}
const published = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
// spawn the server and write each step after the previous one has had time to run (delay in ms)
function session(steps) {
return new Promise(resolve => {
const p = cp.spawn(server, process.argv.slice(3));
let out = Buffer.alloc(0);
p.stdout.on('data', c => { out = Buffer.concat([out, c]); });
p.on('exit', () => resolve(messages(out)));
let at = 0;
const next = () => {
if (at >= steps.length) { p.stdin.write(frame({ jsonrpc: '2.0', method: 'exit' })); return; }
const [delay, msgs] = steps[at++];
p.stdin.write(Buffer.concat(msgs.map(frame)));
setTimeout(next, delay);
};
next();
});
}
const init = { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} };
const open = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version, languageId: 'zc', text } } });
const change = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version }, contentChanges: [{ text }] } });
(async () => {
const A = 'file:///stream.zc';
// a large document with an error at the top: partial lists arrive before the end, the last holds everything
const bad = 'int broken( { }\n' + doc(1500, 'fn main() { return f0(1); }\n');
let msgs = published(await session([[3000, [init, open(A, 1, bad)]]]), A);
assert.ok(msgs.length >= 2, 'a large check streams several lists: ' + msgs.length);
assert.ok(msgs[0].params.diagnostics.some(d => d.severity === 1), 'the first list already has the error');
assert.ok(msgs[msgs.length - 1].params.diagnostics.length >= msgs[0].params.diagnostics.length, 'later lists grow');
// a change that is already waiting drops the stale check: only the newer version is published
const ok = doc(1500, 'fn main() { return f0(1); }\n');
msgs = published(await session([[3000, [init, open(A, 1, ok), change(A, 2, 'fn main() { return 0; }\n')]]]), A);
assert.ok(msgs.length >= 1 && msgs.every(m => m.params.version === 2), 'the stale version 1 is never published: ' + JSON.stringify(msgs.map(m => m.params.version)));
// an interrupted open of another document is still answered once nothing newer waits
const B = 'file:///other.zc';
msgs = await session([[3000, [init, open(A, 1, ok), open(B, 1, 'fn main() { return 0; }\n')]]]);
assert.ok(published(msgs, A).length >= 1 && published(msgs, B).length >= 1, 'both documents are published');
console.log('ok large checks stream partial diagnostics and drop stale checks');
})();
|
