diff options
Diffstat (limited to 'tests/drivers')
35 files changed, 1912 insertions, 0 deletions
diff --git a/tests/drivers/code_address_growth_test.py b/tests/drivers/code_address_growth_test.py new file mode 100644 index 0000000..a454406 --- /dev/null +++ b/tests/drivers/code_address_growth_test.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# native address metadata grows without losing warm translations or rewrite tracking. +import subprocess +import sys + +source = '''o3 int warmed(int value) { return value + 1; } +fn main() { + put_n(warmed(6)); put_c(32); + let code = new(6); + code[0] = code + 3; code[3] = 8; code[4] = 15; code[5] = 18; + put_n(syscall(9, 9, code + 6, 0) >= code + 6); put_c(32); + put_n(code()); put_c(32); + fill_w(code + 4, 19, 1); put_n(code()); put_c(32); + let replacement = new(1); replacement[0] = 23; + copy_w(code + 4, replacement, 1); put_n(code()); put_c(32); + gc(); put_n(warmed(8)); put_c(32); + put_n(syscall(9, 9, syscall(9, 0, 0, 0) + 1, 0) == -1); put_c(10); + return 0; +} +''' +result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=20) +assert result.returncode == 0 and result.stdout == '7 1 7 9 11 9 1\n', (result.returncode, result.stdout, result.stderr) +print('ok new code addresses, warm calls, bulk rewrites, and denied metadata growth') diff --git a/tests/drivers/code_emission_growth_test.py b/tests/drivers/code_emission_growth_test.py new file mode 100644 index 0000000..f13c141 --- /dev/null +++ b/tests/drivers/code_emission_growth_test.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +# emitted code and global data keep their addresses when the program area fills. +import argparse +import subprocess + +parser = argparse.ArgumentParser() +parser.add_argument('--length', type=int, default=600000) +parser.add_argument('command', nargs=argparse.REMAINDER) +options = parser.parse_args() +source = 'int earlier() { return 7; }\n' +source += f'let storage[{options.length}];\n' +source += 'let text = "' + 's' * 3500 + '";\n' +source += 'int later(int n) { return earlier() + n; }\n' +source += '''fn main() { + storage[len(storage) - 1] = 9; + gc(); put_n(later(3)); put_c(32); put_n(storage[len(storage) - 1]); put_c(32); + put_n(len_w(text)); put_c(32); put_n(code_blocks != 0); put_c(32); + let quoted = quote { return 5; }; + put_n(eval(quoted)); put_c(32); + let f = fn(float x) { return x + 1.5; }; put_n((f(2.0) as word) == 0x400c000000000000); put_c(10); + return 0; +} +''' +result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=40) +assert result.returncode == 0 and result.stdout == '10 9 3500 1 5 1\n', (result.returncode, result.stdout, result.stderr) +print('ok linked code segments preserve functions, globals, strings, quotes, and float payloads') + +# force the next float opcode and its payload to need a new segment. +source = 'immediate fn force_edge() { next(); hlimit = here + 3; return 0; }\n' +source += 'fn main() { force_edge let value = 1.5; gc(); put_n((value as word) == 0x3ff8000000000000); put_c(10); return 0; }\n' +result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=20) +assert result.returncode == 0 and result.stdout == '1\n', (result.returncode, result.stdout, result.stderr) +print('ok a float opcode and its payload remain adjacent at a segment boundary') +source = 'immediate fn force_edge() { next(); hlimit = here + 3; return 0; }\n' +source += 'force_edge\nenhance cube(x) vm { 0 $ 0 $ * * };\n' +source += 'enhance sum(a, b) micro "a = add a b";\n' +source += 'fn main() { gc(); put_n(cube(7)); put_c(32); put_n(sum(3, 4)); put_c(10); return 0; }\n' +result = subprocess.run(options.command, input=source, text=True, capture_output=True, timeout=20) +assert result.returncode == 0 and result.stdout == '343 7\n', (result.returncode, result.stdout, result.stderr) +print('ok vm and micro recipes remain contiguous after a code reservation') diff --git a/tests/drivers/compiler_growth_test.py b/tests/drivers/compiler_growth_test.py new file mode 100644 index 0000000..982611c --- /dev/null +++ b/tests/drivers/compiler_growth_test.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +# focused growth checks for compiler columns, stable names, types, and scratch stacks. +import argparse +import subprocess +import sys + +parser = argparse.ArgumentParser() +parser.add_argument('server') +parser.add_argument('--names', type=int, default=18000) +options = parser.parse_args() +server = options.server +assert options.names > 0 + + +def run(source, expected): + result = subprocess.run([server], input=source, text=True, capture_output=True, timeout=30) + assert result.returncode == 0, result.stderr + assert result.stdout == expected, result.stdout[:1000] + + +locals_source = 'fn main() {\n' +locals_source += ''.join(f'int local_{i} = {i};\n' for i in range(900)) +locals_source += 'put_n(local_899); put_c(10); return 0; }\n' +run(locals_source, '899\n') + +types_source = ''.join(f'type array_{i} = [{i + 1}]int;\n' for i in range(1500)) +types_source += 'fn main() { put_n(ntl > 1500); put_c(10); gc(); put_n(tsz(tarr(tint, 1500))); put_c(10); return 0; }\n' +run(types_source, '1\n1500\n') + +names_source = ''.join(f'const int repeated_long_identifier_for_pool_and_hash_growth_{i} = {i};\n' for i in range(options.names)) +names_source += f'''fn main() {{ + word saved = intern("a name that must survive growth"); + reserve_names(hashcap * 4); reserve_symbols(symcap * 2); reserve_locals(loccap * 2); + reserve_fixes(fixcap * 2); reserve_R_SRC(4096); reserve_R_CTX(4096); + reserve_R_LOOP(4096); reserve_R_SNAP(32768); reserve_R_QBUF(32768); reserve_R_EXIT(8192); + gc(); + put_n(saved == intern("a name that must survive growth")); put_c(10); + put_n(repeated_long_identifier_for_pool_and_hash_growth_{options.names - 1}); put_c(10); + put_n(poolblocks != 0 && symcap > NS && hashcap > IHN); put_c(10); + return 0; +}} +''' +run(names_source, f'1\n{options.names - 1}\n1\n') + +long_name = 'identifier_' + 'x' * 1500 +run(f'const int {long_name} = 7; fn main() {{ put_n({long_name}); put_c(10); return 0; }}\n', '7\n') + +mark_source = '''let roots[60000]; +unchecked fn main() { + int i = 0; + while (i < 60000) { roots[i] = new(1); i++; } + gc(); put_n(markcap > MARKN); put_c(32); put_n(live_objects() == 60000); put_c(32); + fill_w(roots, 0, 60000); scrub(); gc(); + // conservative roots can retain incidental addresses in code or untyped words. + put_n(live_objects() < 1000); put_c(10); return 0; +} +''' +run(mark_source, '1 1 1\n') + +generics_source = ''.join(f'int generic_{i}<T>() {{ return sizeof(T); }}\n' for i in range(90)) +generics_source += 'int size_of<T>() { return sizeof(T); }\n' +generics_source += 'fn main() { int total = 0;\n' +generics_source += ''.join(f'total += generic_{i}<int>();\n' for i in range(90)) +generics_source += ''.join(f'total += size_of<[{i + 1}]int>();\n' for i in range(150)) +generics_source += 'gc(); put_n(total); put_c(10); return 0; }\n' +run(generics_source, '11415\n') + +captures_source = 'fn main() {\n' + ''.join(f'int captured_{i} = {i};\n' for i in range(70)) +captures_source += 'let f = fn() { return ' + ' + '.join(f'captured_{i}' for i in range(70)) + '; };\n' +captures_source += 'gc(); put_n(f()); put_c(10); return 0; }\n' +run(captures_source, '2415\n') + +nested_source = 'fn main() { int captured = 7;\n' +nested_source += ''.join(f'let nested_{i} = fn() {{\n' for i in range(12)) +nested_source += 'return captured;\n' +nested_source += ''.join(f'}}; return nested_{i}();\n' for i in reversed(range(1, 12))) +nested_source += '}; gc(); put_n(nested_0()); put_c(10); return 0; }\n' +run(nested_source, '7\n') +assembly_source = 'fn main() { int value = asm { ' + 'future _ ' * 300 +assembly_source += ''.join(f':label_{i} ' for i in range(200)) + ':future 7 }; gc(); put_n(value); put_c(10); return 0; }\n' +run(assembly_source, '7\n') +print('ok compiler tables, long identifiers, and mark work grow without losing references') diff --git a/tests/drivers/core_lsp_test.js b/tests/drivers/core_lsp_test.js new file mode 100644 index 0000000..41d0095 --- /dev/null +++ b/tests/drivers/core_lsp_test.js @@ -0,0 +1,43 @@ +// check maintained zc sources through the editor document protocol, one file at a time. +const assert = require('assert'); +const fs = require('fs'); +const cp = require('child_process'); +const path = require('path'); +const target = process.argv[2]; +const files = ['src/runtime/rt.zc', 'src/compiler/compiler.zc', 'src/runtime/run.zc', 'src/lib/std.zc', 'src/lsp/server.zc', 'src/tools/build.zc']; +const frame = message => { + const body = Buffer.from(JSON.stringify(message)); + return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]); +}; +for (const file of files) { + const uri = 'file://' + path.resolve(file); + const text = fs.readFileSync(file, 'utf8'); + const messages = [ + { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }, + { jsonrpc: '2.0', method: 'initialized', params: {} }, + { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, languageId: 'zc', text } } }, + { jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } }, + { jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version: 2 }, contentChanges: [{ text: text + '\n' }] } }, + { jsonrpc: '2.0', method: 'textDocument/didClose', params: { textDocument: { uri } } }, + { jsonrpc: '2.0', id: 3, method: 'shutdown', params: null }, + { jsonrpc: '2.0', method: 'exit' }, + ]; + const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 30000, maxBuffer: 32 << 20 }); + assert.strictEqual(result.status, 0, file + ': ' + result.stderr); + let data = result.stdout; + const replies = []; + while (data.length) { + const end = data.indexOf('\r\n\r\n'); + assert.ok(end >= 0, 'complete protocol header'); + const length = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]); + replies.push(JSON.parse(data.subarray(end + 4, end + 4 + length))); + data = data.subarray(end + 4 + length); + } + const diagnostics = replies.filter(m => m.method === 'textDocument/publishDiagnostics'); + assert.strictEqual(diagnostics.length, 3, file + ': open, change, and close publish diagnostics'); + const errors = diagnostics.flatMap(m => m.params.diagnostics).filter(d => d.severity === 1); + assert.deepStrictEqual(errors, [], file + ': ' + errors.map(d => (d.range.start.line + 1) + ': ' + d.message).join('\n')); + assert.ok(replies.find(m => m.id === 2).result.data.length, file + ': semantic tokens are available'); + assert.deepStrictEqual(diagnostics[2].params.diagnostics, [], 'close clears diagnostics'); + console.log('ok editor open, highlight, change, and close: ' + file); +} diff --git a/tests/drivers/diagcache_test.js b/tests/drivers/diagcache_test.js new file mode 100644 index 0000000..43966cf --- /dev/null +++ b/tests/drivers/diagcache_test.js @@ -0,0 +1,140 @@ +// the rules of the diagnostics cache (editors/vscode/client/diagcache.js), with +// plain node and no vscode: a key covers the server build, the text, and every +// file the text reads through include, transitively. +// +// node tests/drivers/diagcache_test.js + +const fs = require('fs'); +const os = require('os'); +const path = require('path'); +const assert = require('assert'); +const dc = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'diagcache.js')); + +let passed = 0, failed = 0; +function check(name, fn) { + try { fn(); passed++; console.log('ok ' + name); } + catch (e) { failed++; console.log('FAIL ' + name + ': ' + e.message); } +} + +const root = fs.mkdtempSync(path.join(os.tmpdir(), 'zc-diagcache-')); +const write = (rel, text) => { const p = path.join(root, rel); fs.mkdirSync(path.dirname(p), { recursive: true }); fs.writeFileSync(p, text); return p; }; +const A = write('a.zc', 'include "b.zc";\nfn main() { return helper(); }\n'); +const B = write('b.zc', 'include "c.zc";\n'); +const C = write('c.zc', 'fn helper() { return 1; }\n'); +const U = write('unrelated.zc', 'fn other() { return 2; }\n'); +const aText = fs.readFileSync(A, 'utf8'); + +const keyA = (stamp = 'S1', text = aText, p = A) => dc.diagKey(stamp, text, p, root).key; + +check('includeNames reads every include, however it is spaced', () => { + assert.deepStrictEqual(dc.includeNames('include "a.zc";\ninclude"b/c.zc";\nfn f() {}'), ['a.zc', 'b/c.zc']); + assert.deepStrictEqual(dc.includeNames('fn f() { return 1; }'), []); +}); + +check('includeNames ignores comments and literals while allowing comments between tokens', () => { + assert.deepStrictEqual(dc.includeNames('// include "fake.zc"\n/* include "also-fake.zc" */\nlet s = "include \\"string.zc\\"";\ninclude /* dependency */ "real.zc";'), ['real.zc']); +}); + +check('the same tree gives the same key', () => { + assert.strictEqual(keyA(), keyA()); + assert.match(keyA(), /^[0-9a-f]{64}$/); +}); + +check('a change to the document text changes the key', () => { + assert.notStrictEqual(keyA('S1', aText + ' '), keyA()); +}); + +check('a change to the server build changes the key', () => { + assert.notStrictEqual(keyA('S2'), keyA('S1')); +}); + +check('a change to a file the document includes, two steps down, changes the key', () => { + const before = keyA(); + fs.writeFileSync(C, 'fn helper() { return 3; }\n'); + const after = keyA(); + assert.notStrictEqual(before, after); + fs.writeFileSync(C, 'fn helper() { return 1; }\n'); + assert.strictEqual(keyA(), before, 'putting it back gives the old key again'); +}); + +check('a file nothing includes does not change the key', () => { + const before = keyA(); + fs.writeFileSync(U, 'fn other() { return 9; }\n'); + assert.strictEqual(keyA(), before); +}); + +check('creating a missing include changes the key', () => { + const M = write('m.zc', 'include "later.zc";\nfn f() { return 0; }\n'); + const mText = fs.readFileSync(M, 'utf8'); + const before = dc.diagKey('S1', mText, M, root); + assert.ok(before.deps.some(p => p.endsWith('later.zc')), 'the missing name is still a dependency'); + write('later.zc', 'fn g() { return 1; }\n'); + assert.notStrictEqual(dc.diagKey('S1', mText, M, root).key, before.key); +}); + +check('an include is found from the workspace folder as well as the including file', () => { + const X = write('sub/x.zc', 'include "b.zc";\nfn x() { return 0; }\n'); + const tree = dc.sourceTree(fs.readFileSync(X, 'utf8'), X, root); + assert.ok(tree.files.has(path.join(root, 'b.zc')), 'b.zc is read from the workspace root'); + assert.ok(tree.files.has(path.join(root, 'sub', 'b.zc')), 'and the directory of x.zc is tried too'); + assert.ok(tree.complete); +}); + +check('a tree too large to cover has no key, so nothing is cached for it', () => { + let many = ''; + for (let i = 0; i < dc.MAX_FILES + 5; i++) many += 'include "nope' + i + '.zc";\n'; + const big = write('big.zc', many); + const r = dc.diagKey('S1', many, big, root); + assert.strictEqual(r.key, null); + const cache = new dc.DiagCache(null); + assert.strictEqual(cache.put(r.key, []), false); + assert.strictEqual(cache.size(), 0); +}); + +check('the cache answers only for the key it was given', () => { + const cache = new dc.DiagCache(null); + const d = [{ message: 'x' }]; + assert.ok(cache.put('k1', d)); + assert.deepStrictEqual(cache.get('k1'), d); + assert.strictEqual(cache.get('k2'), null); + assert.strictEqual(cache.get(null), null); + assert.strictEqual(cache.put(null, []), false, 'a tree without a key is not kept'); + assert.strictEqual(cache.size(), 1); +}); + +check('two states of one document are both kept, so going back is a hit', () => { + const cache = new dc.DiagCache(null); + cache.put('state-a', []); + cache.put('state-b', [{ message: 'b' }]); + assert.deepStrictEqual(cache.get('state-a'), []); + assert.deepStrictEqual(cache.get('state-b'), [{ message: 'b' }]); +}); + +check('the least recently used entries go first past the limit', () => { + const cache = new dc.DiagCache(null, 2); + cache.put('1', []); + cache.put('2', []); + cache.get('1'); + cache.put('3', []); + assert.strictEqual(cache.size(), 2); + assert.strictEqual(cache.get('2'), null, 'two was the least recently used'); + assert.deepStrictEqual(cache.get('1'), []); + assert.deepStrictEqual(cache.get('3'), []); +}); + +check('the cache carries over a save and load as plain JSON', () => { + const cache = new dc.DiagCache(null); + cache.put('k1', [{ message: 'z', range: { start: { line: 1, character: 2 } } }]); + const back = new dc.DiagCache(JSON.parse(JSON.stringify(cache))); + assert.deepStrictEqual(back.get('k1'), [{ message: 'z', range: { start: { line: 1, character: 2 } } }]); +}); + +check('a saved entry that is not well formed is dropped, not trusted', () => { + const back = new dc.DiagCache({ bad: { key: 'bad' }, good: [] }); + assert.strictEqual(back.get('bad'), null); + assert.deepStrictEqual(back.get('good'), []); +}); + +fs.rmSync(root, { recursive: true, force: true }); +console.log(passed + ' passed, ' + failed + ' failed'); +process.exit(failed ? 1 : 0); diff --git a/tests/drivers/diagnostic_revision_test.js b/tests/drivers/diagnostic_revision_test.js new file mode 100644 index 0000000..725fb87 --- /dev/null +++ b/tests/drivers/diagnostic_revision_test.js @@ -0,0 +1,47 @@ +// exercise delayed diagnostics without relying on an editor's timing. +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const vm = require('vm'); +const root = path.resolve(__dirname, '../..'); +const displayed = [], cached = []; +const vscode = { + EventEmitter: class { fire() {} }, + SemanticTokensLegend: class {}, + Diagnostic: class { constructor(range, message) { this.message = message; } }, + Range: class {}, + DiagnosticSeverity: { Hint: 4, Information: 3, Warning: 2, Error: 1 }, + Uri: { parse: value => value }, +}; +const filename = path.join(root, 'editors/vscode/client/extension.js'); +const context = vm.createContext({ + module: { exports: {} }, __dirname: path.dirname(filename), Buffer, setTimeout, clearTimeout, + require(name) { + if (name === 'vscode') return vscode; + if (name === './vmproc' || name === './wasmproc') return {}; + if (name.startsWith('./')) return require(path.join(path.dirname(filename), name)); + return require(name); + }, + displayed, cached, +}); +vm.runInContext(fs.readFileSync(filename, 'utf8') + ` +diagnostics = { set(uri, list) { displayed.push(list.map(d => d.message)); } }; +cache = { put(key, raw) { cached.push({ key, raw }); return false; } }; +const uri = 'file:///reopened.zc'; +const diag = message => [{ message, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }]; +opened.add(uri); docKeys.set(uri, 'current'); docVersions.set(uri, 3); +sentKeys.set(uri, [{ key: 'current', version: 3 }]); +onPublish(uri, diag('old close'), 1); +onPublish(uri, diag('old open'), 2); +onPublish(uri, diag('current open'), 3); +onPublish(uri, diag('duplicate'), 3); +opened.delete(uri); +onPublish(uri, diag('closed'), 3); +opened.add(uri); docKeys.set(uri, null); docVersions.set(uri, 5); +sentKeys.set(uri, [{ key: null, version: 4 }, { key: null, version: 5 }]); +onPublish(uri, diag('old uncacheable text'), 4); +onPublish(uri, diag('current uncacheable text'), 5); +`, context, { filename }); +assert.deepStrictEqual(displayed.map(list => Array.from(list)), [['current open'], ['current uncacheable text']]); +assert.deepStrictEqual(cached.map(entry => entry.key), ['current']); +console.log('ok closed, reopened, duplicate, and uncacheable diagnostic revisions'); diff --git a/tests/drivers/enhancement_backends_test.py b/tests/drivers/enhancement_backends_test.py new file mode 100644 index 0000000..b7d553b --- /dev/null +++ b/tests/drivers/enhancement_backends_test.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +# recipes, vm lowering, fallback, and ignored optimizer regions agree across hosts. +import pathlib +import subprocess + +root = pathlib.Path(__file__).resolve().parents[2] +source = (root / 'tests/programs/enhance.zc').read_text() +# keep this focused check short while still exercising signed and unsigned arithmetic. +source = source.replace('i < 5000', 'i < 200') +source += '\n' +reference = None +for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=25) + assert result.returncode == 0 and result.stdout and 'zc:' not in result.stdout, (command, result.returncode, result.stdout, result.stderr) + if reference is None: + reference = result.stdout + else: + assert result.stdout == reference, (command, reference, result.stdout) + print('ok vm recipes, multiple outputs, arithmetic, and fallback: ' + command[0]) +source = '''o3 int increment(int value) { return value + 1; } +fn main() { put_n(increment(6)); put_c(32); put_n(17 / 5); put_c(32); put_n(17 % 5); put_c(10); return 0; } +''' +for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15) + assert result.returncode == 0 and result.stdout == '7 3 2\n', (command, result.stdout, result.stderr) + print('ok optimizer descriptors preserve portable division slots: ' + command[0]) + +# slot zero can be replaced, and an unsupported replacement preserves it. +# real install descriptors are exercised without calling a compiler-specific parser. +source = '''let descriptor[7], names[2]; +fn main() { + names[0] = "a"; names[1] = "b"; + descriptor[0] = 0; descriptor[1] = 0; descriptor[2] = 2; descriptor[3] = 1; + descriptor[4] = "a = add a b"; descriptor[6] = names; + int installed = install(descriptor) == 0, first = 17 / 5; + descriptor[4] = "a = unknown a b"; + int rejected = install(descriptor) < 0, second = 17 / 5; + descriptor[4] = "a = sdiv a b"; install(descriptor); + put_n(installed); put_c(32); put_n(first); put_c(32); put_n(rejected); put_c(32); put_n(second); put_c(10); return 0; +} +''' +for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15) + assert result.returncode == 0 and result.stdout == '1 22 1 22\n', (command, result.stdout, result.stderr) + print('ok replacing a built-in slot and rejecting a bad recipe: ' + command[0]) diff --git a/tests/drivers/ext_cache_test.js b/tests/drivers/ext_cache_test.js new file mode 100644 index 0000000..11bf50b --- /dev/null +++ b/tests/drivers/ext_cache_test.js @@ -0,0 +1,154 @@ +// the extension's diagnostics cache, end to end: the real client +// (editors/vscode/client/extension.js) with a stub for the vscode module, and +// the built-in wasm server. the checks: a first session asks the server and +// saves the answer; a second session shows the saved answer before the server +// starts; a change to an included file is checked again; putting it back is +// answered from the cache. +// +// node tests/drivers/ext_cache_test.js + +const fs = require('fs'); +const os = require('os'); +const path = require('path'); +const Module = require('module'); + +const client = path.join(__dirname, '..', '..', 'editors', 'vscode', 'client'); + +// the vscode module, as far as the client uses it +const world = { lines: [], sets: [], listeners: {}, watchers: [], textDocuments: [], saved: undefined, root: '' }; +const stub = { + EventEmitter: class { constructor() { this.event = () => ({ dispose() {} }); } fire() {} }, + Diagnostic: class { constructor(range, message, severity) { Object.assign(this, { range, message, severity }); } }, + Range: class { constructor(a, b, c, d) { Object.assign(this, { start: { line: a, character: b }, end: { line: c, character: d } }); } }, + DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 }, + SemanticTokensLegend: class { constructor(t, m) { this.tokenTypes = t; this.tokenModifiers = m; } }, + SemanticTokensBuilder: class { constructor() {} push() {} build() { return null; } }, + MarkdownString: class { + constructor(v = '') { this.value = v; this.escaped = false; } + appendText(v) { this.value += v; this.escaped = true; return this; } + appendMarkdown(v) { this.value += v; return this; } + appendCodeblock(v, language) { this.value += '\n```' + language + '\n' + v + '\n```\n'; return this; } + }, + Hover: class { constructor(c) { this.contents = c; } }, + Uri: { parse: s => ({ toString: () => s, fsPath: decodeURIComponent(s.replace(/^file:\/\//, '')) }) }, + workspace: { + workspaceFolders: undefined, + textDocuments: world.textDocuments, + getConfiguration: () => ({ get: () => undefined }), + createFileSystemWatcher: () => { + const w = { handlers: {}, dispose() {} }; + world.watchers.push(w); + for (const k of ['onDidChange', 'onDidCreate', 'onDidDelete']) w[k] = f => { w.handlers[k] = f; return { dispose() {} }; }; + return w; + }, + ...['onDidChangeConfiguration', 'onDidOpenTextDocument', 'onDidChangeTextDocument', 'onDidSaveTextDocument', 'onDidCloseTextDocument'] + .reduce((o, k) => { o[k] = f => { world.listeners[k] = f; return { dispose() {} }; }; return o; }, {}), + }, + window: { + createOutputChannel: () => ({ appendLine: s => world.lines.push(String(s)), show() {}, dispose() {} }), + showWarningMessage() {}, showErrorMessage() {}, + }, + languages: { + createDiagnosticCollection: () => ({ + set: (uri, list) => world.sets.push({ uri: uri.toString(), list, at: world.lines.length }), + delete() {}, dispose() {}, + }), + registerDocumentSemanticTokensProvider: () => ({ dispose() {} }), + registerHoverProvider: (sel, p) => { world.hover = p; return { dispose() {} }; }, + }, + commands: { registerCommand: () => ({ dispose() {} }) }, +}; +const realResolve = Module._resolveFilename; +Module._resolveFilename = function (req, ...rest) { return req === 'vscode' ? 'vscode' : realResolve.call(this, req, ...rest); }; +require.cache['vscode'] = { id: 'vscode', filename: 'vscode', loaded: true, exports: stub }; + +let passed = 0, failed = 0; +function check(name, ok, detail) { + if (ok) { passed++; console.log('ok ' + name); } + else { failed++; console.log('FAIL ' + name + (detail ? ': ' + detail : '')); } +} +const sleep = ms => new Promise(r => setTimeout(r, ms)); +async function until(pred, ms = 20000) { + const end = Date.now() + ms; + while (Date.now() < end) { if (pred()) return true; await sleep(50); } + return pred(); +} + +function freshClient() { + for (const f of Object.keys(require.cache)) if (f.startsWith(client)) delete require.cache[f]; + return require(path.join(client, 'extension.js')); +} + +const root = fs.mkdtempSync(path.join(os.tmpdir(), 'zc-extcache-')); +stub.workspace.workspaceFolders = [{ uri: { fsPath: root } }]; +const helper = path.join(root, 'helper.zc'); +const main = path.join(root, 'main.zc'); +const helperOk = 'fn helper() { return 1; }\n'; +const helperBad = 'fn helper2() { return 1; }\n'; +fs.writeFileSync(helper, helperOk); +const mainText = 'include "helper.zc";\nfn main() { return helper(); }\n'; +fs.writeFileSync(main, mainText); + +function doc(p, text) { + const d = { uri: { toString: () => 'file://' + p, fsPath: p }, languageId: 'zc', version: 1, text, getText() { return this.text; } }; + return d; +} + +const ctx = () => ({ + subscriptions: [], + globalState: { get: () => world.saved, update: (k, v) => { world.saved = JSON.parse(JSON.stringify(v)); return Promise.resolve(); } }, +}); +const mainDoc = doc(main, mainText); +const mainUri = 'file://' + main; + +(async () => { + // session one: nothing cached, so the server is asked + world.textDocuments.push(mainDoc); + let ext = freshClient(); + let c1 = ctx(); + ext.activate(c1); + check('session one: the server starts and checks the document', await until(() => world.lines.some(l => /server ready/.test(l))) && await until(() => world.sets.some(s => s.uri === mainUri))); + const first = world.sets.filter(s => s.uri === mainUri).pop(); + check('session one: the server answered with a list', first && Array.isArray(first.list), JSON.stringify(first && first.list)); + await sleep(800); + const savedKeys = Object.keys(world.saved || {}); + // the hover is the server's markdown, parsed: a zc code block, not escaped text + const hv = world.hover && await world.hover.provideHover(mainDoc, { line: 1, character: 4 }); + const hc = hv && hv.contents[0]; + check('the hover is markdown with a zc code block, parsed and not escaped', hc && !hc.escaped && /^```zc\n/.test(hc.value) && /\n```/.test(hc.value), JSON.stringify(hc)); + check('session one: the answer is saved under a key', savedKeys.length === 1 && /^[0-9a-f]{64}$/.test(savedKeys[0]), JSON.stringify(savedKeys)); + ext.deactivate(); + await sleep(700); + + // session two: the saved answer is shown before the server has started + world.lines.length = 0; world.sets.length = 0; + ext = freshClient(); + ext.activate(ctx()); + check('session two: the saved diagnostics are shown at once', world.sets.some(s => s.uri === mainUri) && world.lines.some(l => /from the cache/.test(l))); + check('session two: the server has not started yet', !world.lines.some(l => /server ready/.test(l))); + await until(() => world.lines.some(l => /server ready/.test(l))); + await sleep(300); + check('session two: the server was not asked about the document', !world.lines.some(l => /-> textDocument\/didOpen|-> textDocument\/didChange/.test(l)), JSON.stringify(world.lines.slice(0, 6))); + check('session two: the cache holds the same key as before', JSON.stringify(Object.keys(world.saved || {})) === JSON.stringify(savedKeys)); + + // a change to the included file, saved: the document is checked again and the error shows + world.lines.length = 0; world.sets.length = 0; + fs.writeFileSync(helper, helperBad); + for (const h of world.watchers) if (h.handlers.onDidChange) h.handlers.onDidChange({ fsPath: helper }); + check('an included file changed: the document is checked again', await until(() => world.lines.some(l => /-> textDocument\/didOpen|-> textDocument\/didChange/.test(l)) && world.sets.some(s => s.uri === mainUri)), JSON.stringify(world.lines.slice(-4))); + await sleep(900); + check('an included file changed: the new state is saved under its own key', Object.keys(world.saved || {}).length === 2, JSON.stringify(Object.keys(world.saved || {}))); + + // the file goes back: its tree is the one the cache has, so the old answer is shown from the cache + world.lines.length = 0; world.sets.length = 0; + fs.writeFileSync(helper, helperOk); + for (const h of world.watchers) if (h.handlers.onDidChange) h.handlers.onDidChange({ fsPath: helper }); + await sleep(200); + check('the old tree is answered from the cache, without asking the server', world.lines.some(l => /from the cache/.test(l)) && !world.lines.some(l => /-> textDocument\/didChange/.test(l)), JSON.stringify(world.lines.slice(-4))); + + ext.deactivate(); + await sleep(700); + fs.rmSync(root, { recursive: true, force: true }); + console.log(passed + ' passed, ' + failed + ' failed'); + process.exit(failed ? 1 : 0); +})().catch(e => { console.log('FAIL harness: ' + (e.stack || e)); process.exit(1); }); diff --git a/tests/drivers/float_backends_test.py b/tests/drivers/float_backends_test.py new file mode 100644 index 0000000..2cb9473 --- /dev/null +++ b/tests/drivers/float_backends_test.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +# compare float instructions, packed binary32 conversion, and decimal output. +import pathlib +import subprocess + +root = pathlib.Path(__file__).resolve().parents[2] +commands = [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']] +sources = [(root / 'tests/programs/float.zc').read_text(), '''fn render(bits, precision, mode) { asm { bits @ precision @ mode @ #1236 } return 0; } +fn convert(bits) { return asm { bits @ #1218 }; } +fn main() { + [4]f32 values; + values[0] = 1.5; values[1] = -2.25; values[2] = 1e-45; values[3] = 1e40; + put_n(values[0] == 1.5); put_c(32); put_n(values[1] == -2.25); put_c(32); + put_n(values[2] > 0.0); put_c(32); put_n(values[3] == 1.0 / 0.0); put_c(10); + render(0.125, 2, 1); put_c(32); render(-0.125, 2, 1); put_c(32); + render(1e30, 6, 1); put_c(32); render(1.7976931348623157e308, 6, 1); put_c(10); + render(0.1, 0, 0); put_c(32); render(1e-5, 0, 0); put_c(32); render(1e16, 0, 0); put_c(10); + render(9.999, 3, 2); put_c(32); render(5e-324, 3, 2); put_c(32); render(0, 3, 2); put_c(10); + let negative_zero = 1 << 63; render(negative_zero, 6, 1); put_c(32); render(negative_zero, 0, 0); put_c(10); + put_n(convert(0.0 / 0.0)); put_c(32); put_n(convert(1.0 / 0.0)); put_c(32); put_n(convert(-1.0 / 0.0)); put_c(10); + return 0; +} +'''] +expected_arithmetic = '4.000000 4.500000 3.000000 2.500000 2.500000 0.001500 0.100000 -0.125000 inf -inf nan 1 1 1 0 0 3 -3 3.000000 -2.000000 2\n' +for i, source in enumerate(sources): + reference = None + for command in commands: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=30) + assert result.returncode == 0 and result.stdout and 'zc:' not in result.stdout, (command, result.returncode, result.stdout, result.stderr) + if reference is None: + if i == 0: + assert result.stdout == expected_arithmetic, result.stdout + else: + assert result.stdout.startswith('1 1 1 1\n0.13 -0.13 '), result.stdout + assert result.stdout.endswith('0 9223372036854775807 -9223372036854775808\n'), result.stdout + reference = result.stdout + else: + assert result.stdout == reference, (command, i, reference, result.stdout) + print('ok float arithmetic and output fixture ' + str(i + 1) + ': ' + command[0]) + +# an exponent after a long fractional spelling must reach the parser intact. +literal = '1.' + '0' * 300 + 'e1' +source = f'fn main() {{ put_n(({literal} as word) == 0x4024000000000000); put_c(10); return 0; }}\n' +for command in commands: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=15) + assert result.returncode == 0 and result.stdout == '1\n', (command, result.stdout, result.stderr) + print('ok float parsing reads the exponent beyond 127 characters: ' + command[0]) diff --git a/tests/drivers/frame_growth_test.py b/tests/drivers/frame_growth_test.py new file mode 100644 index 0000000..74156e3 --- /dev/null +++ b/tests/drivers/frame_growth_test.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +# growing frames keep pointers into older segments alive through collection. +import subprocess +import sys + +command = sys.argv[1:] +source = '''unchecked int descend(int depth, int* root) { + [2000]int padding; + padding[0] = depth; + if (depth == 0) { gc(); return *root; } + return descend(depth - 1, root) + padding[0]; +} +unchecked int oversized(int* root) { + [300000]int values; + values[0] = *root; values[299999] = 9; + gc(); return values[0] + values[299999]; +} +unchecked fn main() { + int value = 7; + put_n(descend(300, &value)); put_c(32); + put_n(oversized(&value)); put_c(32); + gc(); put_n(frame_node == 0); put_c(10); + return 0; +} +''' +result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=40) +assert result.returncode == 0 and result.stdout == '45157 16 1\n', (command, result.returncode, result.stdout, result.stderr) +print('ok deep and oversized frames preserve borrowed locals through collection: ' + command[0]) +optimized = source.replace('unchecked int descend', 'unchecked o3 int descend').replace('unchecked int oversized', 'unchecked o3 int oversized') +result = subprocess.run(command, input=optimized, text=True, capture_output=True, timeout=40) +assert result.returncode == 0 and result.stdout == '45157 16 1\n', (command, result.returncode, result.stdout, result.stderr) +print('ok optimized recursive calls wait for the matching return depth: ' + command[0]) diff --git a/tests/drivers/genome_blob_test.py b/tests/drivers/genome_blob_test.py new file mode 100644 index 0000000..81533a7 --- /dev/null +++ b/tests/drivers/genome_blob_test.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +# documentation precedes the symbol table; the boot header must skip those bytes. +import pathlib +import re + +source = pathlib.Path('src/core/genome.h').read_text() +org = int(re.search(r'#define GORG (\d+)', source)[1]) +length = int(re.search(r'#define GLEN (\d+)', source)[1]) +words = [int(word.strip()) for word in re.search(r'genome\[\]\s*=\s*\{([\s\S]*?)\};', source)[1].split(',') if word.strip()] +assert len(words) == length and words[6] == org + length +cursor = words[5] - org +assert 7 <= cursor < length +records = {} +while words[cursor]: + kind, value, signature = words[cursor:cursor + 3] + assert kind in (1, 2, 3, 4, 6, 8), (cursor, kind) + cursor += 3 + name = '' + while words[cursor]: + assert 0 < words[cursor] < 128, (cursor, words[cursor]) + name += chr(words[cursor]) + cursor += 1 + cursor += 1 + records[name] = (kind, value, signature) +assert cursor == length - 1 +assert len(records) > 1000 and records['start'][0] == 1 +assert records['reserve_code'][0] == 1 and records['build_image_grow'][0] == 1 +assert any(name.startswith('doc ') for name in records), 'the fixture contains documentation bytes' +for name, (kind, value, _) in records.items(): + if kind == 8: + assert org <= value < org + length and words[value - org] >= 0, name +print('ok documented genome starts its symbol table at the header address') diff --git a/tests/drivers/hover_features_test.js b/tests/drivers/hover_features_test.js new file mode 100644 index 0000000..895e923 --- /dev/null +++ b/tests/drivers/hover_features_test.js @@ -0,0 +1,85 @@ +// focused type, inference, and block-documentation hover regressions. +// usage: node tests/drivers/hover_features_test.js path/to/zclsp +const assert = require('assert'); +const cp = require('child_process'); +const server = process.argv[2]; +const uri = 'file:///hover-features.zc'; +const frame = m => { + const body = Buffer.from(JSON.stringify(m)); + return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]); +}; +function hover(text, needle, nth = 0) { + let offset = -1; + for (let i = 0; i <= nth; i++) offset = text.indexOf(needle, offset + 1); + assert.ok(offset >= 0, 'fixture contains ' + needle); + const before = text.slice(0, offset); + const line = before.split('\n').length - 1; + const character = before.length - before.lastIndexOf('\n') - 1; + const messages = [ + { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }, + { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, languageId: 'zc', text } } }, + { jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line, character } } }, + { jsonrpc: '2.0', method: 'exit' }, + ]; + const result = cp.spawnSync(server, process.argv.slice(3), { input: Buffer.concat(messages.map(frame)), timeout: 10000, maxBuffer: 4 << 20 }); + assert.strictEqual(result.status, 0, String(result.stderr)); + let data = result.stdout; + while (data.length) { + const end = data.indexOf('\r\n\r\n'); + const count = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]); + const msg = JSON.parse(data.subarray(end + 4, end + 4 + count).toString()); + data = data.subarray(end + 4 + count); + if (msg.id === 2) return msg.result && msg.result.contents.value; + } + return null; +} +for (const type of ['word', 'int', 'char', 'bool', 'float', 'f64', 'f32', 'byte', 'u8', 'i8', 'u16', 'i16', 'u32', 'i32']) { + const value = hover(type + ' global;\nfn main() { return 0; }\n', type); + assert.ok(value && value.startsWith('```zc\n') && value.includes('\n\n'), type + ' has formatted built-in documentation'); +} +assert.match(hover('void noop() {}\nfn main() { return 0; }\n', 'void'), /no meaningful result/); +const array = 'fn main() {\n [4]u8 values;\n return values[0];\n}\n'; +assert.match(hover(array, '[4]'), /fixed length of 4/); +assert.match(hover(array, 'values', 1), /type \[4\]u8/); +const struct = 'struct pair { int left; float right; };\nfn main() { pair value; return value.left; }\n'; +assert.match(hover(struct, 'pair', 1), /int left;[\s\S]*float right;/); +assert.match(hover(struct, 'value', 1), /type pair/); +const fields = 'struct pair { int /* left field */ left, /* right field */ right; };\nfn main() { pair p; return p.left + p.right; }\n'; +assert.match(hover(fields, 'left +'), /field; type int[\s\S]*left field/); +assert.match(hover(fields, 'right;'), /field; type int[\s\S]*right field/); +const empty = '/**/ int helper() { return 1; }\nfn main() { return helper(); }\n'; +assert.match(hover(empty, 'helper();'), /int helper\(\)/); +const variableDocs = 'fn main() {\n int /* first variable */ first = 1, /* second variable */ second = 2;\n return first + second;\n}\n'; +const first = hover(variableDocs, 'first +'); +const second = hover(variableDocs, 'second;'); +assert.ok(first.includes('first variable') && !first.includes('second variable'), first); +assert.ok(second.includes('second variable') && !second.includes('first variable'), second); +const paramDocs = 'int add(int /* left argument */ a, int /* right argument */ b) { return a + b; }\nfn main() { return add(1, 2); }\n'; +const a = hover(paramDocs, 'a +'); +const b = hover(paramDocs, 'b;'); +assert.ok(a.includes('left argument') && !a.includes('right argument'), a); +assert.ok(b.includes('right argument') && !b.includes('left argument'), b); +const functionDocs = '/**\n * adds **one** to its argument.\n */\nint add(int x) { return x + 1; }\nfn main() { return add(2); }\n'; +assert.match(hover(functionDocs, 'add(2)'), /adds \*\*one\*\*/); +const inferred = 'fn twice(x) { return x * 2; }\nfn main() { let value = twice(3); return value; }\n'; +assert.match(hover(inferred, 'twice(3)'), /int twice\(int x\)/); +assert.match(hover(inferred, 'x *'), /type int/); +assert.match(hover(inferred, 'value;'), /type int/); +const pointer = 'int read(int* p) { return p[0]; }\nfn main() { int value = 3; return read(&value); }\n'; +assert.match(hover(pointer, 'p[0]'), /type int\*[\s\S]*pointer to `int`/); +const alias = 'type row = [3]int;\nfn main() { row values; return values[0]; }\n'; +assert.match(hover(alias, 'row values'), /\[3\]int[\s\S]*fixed length of 3/); +const enumeration = 'enum color { red, green = 5, blue };\nfn main() { color shade = green; return shade; }\n'; +assert.match(hover(enumeration, 'shade;'), /type color/); +const dynamic = 'fn main() { []int items; push(items, 3); return len(items); }\n'; +assert.match(hover(dynamic, 'items);'), /type \[\]int[\s\S]*growable array handle/); +const callable = 'fn main() { let apply = fn(int x) { return x + 1; }; return apply(2); }\n'; +assert.match(hover(callable, 'apply(2)'), /type .*\([\s\S]*callable value/); +assert.match(hover(callable, 'apply(2)'), /type int\(int\)/); +const floatClosure = 'fn main() { let f = fn(float x) { return x + 1.5; }; let result = f(2.0); return result; }\n'; +assert.match(hover(floatClosure, 'result;'), /type float/); +const inferredPointer = 'struct node { int value; };\nfn make_node() { return new(node); }\nfn main() { let p = make_node(); return p.value; }\n'; +assert.match(hover(inferredPointer, 'p.value'), /type node\*/); +const aggregateAlias = 'fn main() { [3]int a; a[1] = 7; let alias = a; return alias[1]; }\n'; +assert.match(hover(aggregateAlias, 'alias[1]'), /type int\*/); +console.log('ok built-in and composite types, inferred signatures, and separate block docs'); diff --git a/tests/drivers/hover_test.js b/tests/drivers/hover_test.js new file mode 100644 index 0000000..10af643 --- /dev/null +++ b/tests/drivers/hover_test.js @@ -0,0 +1,23 @@ +// protocol conversion checks. run with node tests/drivers/hover_test.js. +const assert = require('assert'); +const { hoverContents } = require('../../editors/vscode/client/hover'); +class MarkdownString { + constructor() { this.value = ''; this.calls = []; } + appendMarkdown(value) { this.calls.push('markdown'); this.value += value; return this; } + appendText(value) { this.calls.push('text'); this.value += value; return this; } + appendCodeblock(value, language) { this.calls.push('code'); this.value += '\n```' + language + '\n' + value + '\n```\n'; return this; } +} +const api = { MarkdownString }; +const markdown = '```zc\nint add(int a, int b)\n```\n\nAdds **two** numbers.'; +const md = hoverContents(api, { kind: 'markdown', value: markdown })[0]; +assert.strictEqual(md.value, markdown); +assert.deepStrictEqual(md.calls, ['markdown']); +assert.strictEqual(md.isTrusted, false); +assert.strictEqual(md.supportHtml, false); +assert.deepStrictEqual(hoverContents(api, { kind: 'plaintext', value: '*literal*' })[0].calls, ['text']); +const legacy = hoverContents(api, { language: 'zc', value: 'int x;' })[0]; +assert.match(legacy.value, /```zc\nint x;\n```/); +assert.deepStrictEqual(legacy.calls, ['code']); +assert.strictEqual(hoverContents(api, ['**Doc**', { language: 'zc', value: 'fn main()' }]).length, 2); +for (const contents of [null, undefined, '', [], {}, { value: 123 }]) assert.deepStrictEqual(hoverContents(api, contents), []); +console.log('ok hover conversion preserves Markdown, plaintext, code, and arrays'); diff --git a/tests/drivers/image_growth_test.py b/tests/drivers/image_growth_test.py new file mode 100644 index 0000000..064eae7 --- /dev/null +++ b/tests/drivers/image_growth_test.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +# image output can grow past its first buffer and the building host's genome slot. +import pathlib +import subprocess +import sys + +root = pathlib.Path(__file__).resolve().parents[2] +source = '''fn main() { + int retained = 7; + int n = build_image_grow(GORG, 8); + gc(); + put_n(n > FBOT - GORG); put_c(32); + put_n(image_size == n && image_words[6] == GORG + n); put_c(32); + put_n(image_words[5] > GORG && image_words[5] < image_words[6]); put_c(32); + put_n(retained); put_c(10); + return 0; +} +`''' +source += (root / 'src/runtime/rt.zc').read_text() +source += (root / 'src/runtime/run.zc').read_text() +source += 'let padding[350000]; fn main() { return padding[349999]; }\n' +result = subprocess.run(sys.argv[1:], input=source, capture_output=True, text=True, timeout=40) +assert result.returncode == 0, (result.stdout, result.stderr) +assert result.stdout == '1 1 1 7\n', result.stdout[:1000] +print('ok growing image output keeps logical addresses and older frames intact') diff --git a/tests/drivers/image_run.js b/tests/drivers/image_run.js new file mode 100644 index 0000000..6d0b949 --- /dev/null +++ b/tests/drivers/image_run.js @@ -0,0 +1,14 @@ +// run a generated image directly, avoiding compiler time in vm execution tests. +const fs = require('fs'); +const { TinyVM } = require('../../src/js/tinyvm.js'); +const { mapValues } = require('../../src/js/mapvalues.js'); +const header = fs.readFileSync(process.argv[2], 'utf8'); +const org = Number(header.match(/#define\s+GORG\s+(\d+)/)[1]); +const words = header.match(/genome\[\]\s*=\s*\{([\s\S]*?)\};/)[1].split(',').map(s => s.trim()).filter(Boolean); +const layout = mapValues(process.argv[3], ['GORG', 'DS0', 'DSLIM', 'RS0', 'RSLIM', 'SYSGATE', 'ZFP', 'HEAP_LO', 'HEAP_HI']); +const machine = new TinyVM({ layout, onMessage: message => process.stderr.write(message) }); +machine.loadGenome(words, org); +if (process.argv[4] === '--stdin') machine.setInput(fs.readFileSync(0)); +const status = machine.run(); +process.stdout.write(machine.getOutput()); +process.exit(status); diff --git a/tests/drivers/inference_growth_test.py b/tests/drivers/inference_growth_test.py new file mode 100644 index 0000000..d747f70 --- /dev/null +++ b/tests/drivers/inference_growth_test.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +# infer past the original function-record and edit-count limits. +import re +import subprocess +import sys + +source = ''.join(f'fn function_{i}(x) {{ return x + 1; }}\n' for i in range(600)) +source += 'fn main() {\n' +source += ''.join(f'let value_{i} = {i};\n' for i in range(5000)) +source += ''.join(f'function_{i}(1);\n' for i in range(600)) +source += 'return value_4999; }\n' +result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=45) +assert result.returncode == 0, result.stderr +assert re.search(r'int function_599\(int x\)', result.stdout), result.stdout[-1000:] +assert 'int value_4999 = 4999;' in result.stdout, result.stdout[-1000:] +assert 'let value_' not in result.stdout, 'later inference edits were dropped' +print('ok inference handles 600 functions and 5000 local declarations') + +# later parameters and nested functions retain the enclosing inference context. +params = ', '.join(f'arg_{i}' for i in range(20)) +source = f'fn wide({params}) {{ let nested = fn(int y) {{ return y + 1; }}; return arg_19 + nested(1); }}\n' +source += 'fn main() { return wide(' + ', '.join('1' for _ in range(20)) + '); }\n' +result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=15) +assert result.returncode == 0, result.stderr +assert 'int arg_19' in result.stdout, result.stdout +assert 'int wide(' in result.stdout, result.stdout +print('ok later arguments and nested closures preserve inferred signatures') + +source = 'struct point { int x, y; };\nfn main() { let a[3]; a[1] = 7; let alias = a; point p; p.x = 9; let ref = p; return alias[1] + ref.x; }\n' +result = subprocess.run([sys.argv[1], '--annotate'], input=source, text=True, capture_output=True, timeout=15) +assert result.returncode == 0 and 'word* alias' in result.stdout and 'point* ref' in result.stdout, result.stdout +again = subprocess.run([sys.argv[1], '--annotate'], input=result.stdout, text=True, capture_output=True, timeout=15) +assert again.returncode == 0 and again.stdout == result.stdout, again.stdout +print('ok array and struct aliases get compatible pointer annotations') diff --git a/tests/drivers/layout_config_test.py b/tests/drivers/layout_config_test.py new file mode 100644 index 0000000..469e7dd --- /dev/null +++ b/tests/drivers/layout_config_test.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +# generated layouts expose initial reservations and reject arithmetic overflow. +import pathlib +import subprocess +import tempfile + +root = pathlib.Path(__file__).resolve().parents[2] +tool = root / 'bin/genmap' +result = subprocess.run([tool, '--help'], capture_output=True, text=True) +assert result.returncode == 0 and '--generated-text' in result.stderr +invalid = [ + ['--symbols', '2147483647'], ['--code', '2147483647'], + ['--frame', '2147483647'], ['--return', '2147483647'], + ['--asm-labels', '2147483647'], ['--enum-members', '2147483647'], + ['--regions', '2147483647'], ['--heap', '7'], ['--hash', '3'], +] +for options in invalid: + result = subprocess.run([tool, '--preset', 'default', *options], capture_output=True, text=True) + assert result.returncode != 0 and result.stderr, options +with tempfile.TemporaryDirectory(dir=root / 'build') as directory: + options = ['--asm-labels', '4', '--asm-refs', '8', '--exit', '32', '--enum-members', '8', '--tagged-enums', '2', '--methods', '2', '--generated-text', '64', '--facts', '2', '--paths', '2', '--regions', '2'] + subprocess.run([tool, '--preset', 'default', *options, '-o', directory], check=True, capture_output=True) + source = (pathlib.Path(directory) / 'compiler.zc').read_text() + for name, value in [('ASM_LABELS', '4'), ('ASM_REFS', '8'), ('EXIT_WORDS', '20'), ('ENUM_MEMBERS', '8'), ('TAGGED_ENUMS', '2'), ('STRUCT_METHODS', '2'), ('GENERATED_WORDS', '40'), ('RANGE_FACTS', '2'), ('JOIN_PATHS', '2'), ('O3_REGIONS', '2')]: + assert f'const {name} = 0x{value};' in source, name +print('ok parser layout controls and invalid configuration checks') diff --git a/tests/drivers/learn.py b/tests/drivers/learn.py new file mode 100644 index 0000000..42f729f --- /dev/null +++ b/tests/drivers/learn.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# checks docs/LEARN.md against the examples it shows. every examples/learn/*.zc runs +# from the repo root with its stdout compared to the matching .out file, and +# every ```zc block in docs/LEARN.md must be exactly one of those files, so the +# guide can't drift from the code it teaches. usage: learn.py path/to/zy +import glob, os, platform, re, subprocess, sys + +root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.chdir(root) +zy = os.path.abspath(sys.argv[1]) +x86_only = {"22-raw-x86"} +bad = 0 + +def ok(name): + print(f"ok {name}") + +def fail(name, why): + global bad + bad += 1 + print(f"FAIL {name}: {why}") + +files = sorted(glob.glob("examples/learn/*.zc")) +for path in files: + name = os.path.splitext(os.path.basename(path))[0] + if name in x86_only and platform.machine() not in ("x86_64", "AMD64"): + print(f"skip {name} (x86-64 only)") + continue + with open(path, "rb") as f: + src = f.read() + try: + r = subprocess.run([zy], stdin=open(path, "rb"), capture_output=True, timeout=30) + except subprocess.TimeoutExpired: + fail(f"learn {name}", "timed out") + continue + got = r.stdout.decode("utf-8", "replace") + want_path = os.path.splitext(path)[0] + ".out" + if not os.path.exists(want_path): + fail(f"learn {name}", f"no {want_path}") + elif got == open(want_path, encoding="utf-8").read(): + ok(f"learn {name} prints what it says") + else: + fail(f"learn {name}", f"got [{got}]") + +# every zc block in docs/LEARN.md is one of the example files +with open("docs/LEARN.md", encoding="utf-8") as f: + doc = f.read() +blocks = re.findall(r"^```zc\n(.*?)^```", doc, re.S | re.M) +srcs = {} +for path in files: + with open(path, encoding="utf-8") as f: + srcs[os.path.basename(path)] = f.read() +used = set() +for b in blocks: + hit = [n for n, s in srcs.items() if s == b] + if hit: + used.add(hit[0]) + else: + fail("learn block", "a ```zc block in docs/LEARN.md is not an examples/learn file: " + b.splitlines()[0]) +for n in srcs: + if n not in used: + fail(f"learn {n}", "not shown in docs/LEARN.md") +if not bad: + ok(f"docs/LEARN.md: {len(blocks)} blocks, all match examples/learn") +sys.exit(1 if bad else 0) diff --git a/tests/drivers/local_index_test.py b/tests/drivers/local_index_test.py new file mode 100644 index 0000000..95bfd78 --- /dev/null +++ b/tests/drivers/local_index_test.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# local name heads survive shadowing, scope reuse, closures, and context switches. +import subprocess +import sys +source = ''' +fn choose(int x) { + let total = x; + { let x = 7; total += x; } + { let x = 9; total += x; } + let f = fn(int x) { return x + 1; }; + let g = fn() { return total; }; + return total + x + f(3) + g(); +} +o3 int fast(int x) { int result = x; { int x = 8; result += x; } return result + x; } +fn main() { put_n(choose(2)); put_c(32); put_n(fast(3)); put_c(10); return 0; } +''' +result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=15) +assert result.returncode == 0 and result.stdout == '42 14\n', (result.returncode, result.stdout, result.stderr) +print('ok local shadow chains, reused scopes, closure parameters, captures, and o3 contexts') +source = 'struct point { int x, y; };\nfn main() { let a[3]; a[1] = 7; let alias = a; point p; p.x = 9; let ref = p; put_n(alias[1]); put_c(32); put_n(ref.x); put_c(10); return 0; }\n' +result = subprocess.run(sys.argv[1:], input=source, text=True, capture_output=True, timeout=15) +assert result.returncode == 0 and result.stdout == '7 9\n', (result.returncode, result.stdout, result.stderr) +print('ok inferred aliases load array and struct addresses rather than the alias slot') diff --git a/tests/drivers/lsp_growth_test.js b/tests/drivers/lsp_growth_test.js new file mode 100644 index 0000000..b06230a --- /dev/null +++ b/tests/drivers/lsp_growth_test.js @@ -0,0 +1,53 @@ +// focused regressions for growing document, uri, hover, and name-set storage. +// usage: node tests/drivers/lsp_growth_test.js path/to/zclsp-or-lsp.wasm +const assert = require('assert'); +const cp = require('child_process'); +const { wasmProcess } = require('../../editors/vscode/client/wasmproc'); +const target = process.argv[2]; +const frame = m => { + const body = Buffer.from(JSON.stringify(m)); + return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\n\r\n'), body]); +}; +function parse(input) { + const messages = []; + for (let offset = 0; offset < input.length;) { + const end = input.indexOf('\r\n\r\n', offset); + assert.ok(end >= 0, 'complete response header'); + const length = Number(/Content-Length:\s*(\d+)/i.exec(input.subarray(offset, end).toString())[1]); + const start = end + 4; + assert.ok(start + length <= input.length, 'complete response body'); + messages.push(JSON.parse(input.subarray(start, start + length).toString())); + offset = start + length; + } + return messages; +} +const uri = 'file:///' + 'long-directory/'.repeat(30) + 'main.zc'; +const docs = '// **formatted** documentation with `inline code`.\n' + ('// a long paragraph of documentation.\n').repeat(150) + '// final documentation line\n'; +const source = docs + 'int helper() { return 1; }\nfn main() { return helper(); }\n'; +const messages = [{ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }]; +for (let i = 0; i < 32; i++) messages.push({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri: i === 31 ? uri : 'file:///doc' + i + '.zc', languageId: 'zc', version: 1, text: source } } }); +messages.push({ jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: source.split('\n').length - 2, character: 19 } } }); +messages.push({ jsonrpc: '2.0', method: 'exit' }); +let output; +if (target.endsWith('.wasm')) { + const chunks = []; + const server = wasmProcess(target); + server.stdout.on('data', data => chunks.push(data)); + for (const message of messages) assert.ok(server.stdin.write(frame(message))); + output = Buffer.concat(chunks); +} else { + const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 30000, maxBuffer: 8 << 20 }); + assert.strictEqual(result.status, 0, String(result.stderr)); + output = result.stdout; +} +const responses = parse(output); +const published = responses.filter(m => m.method === 'textDocument/publishDiagnostics'); +assert.strictEqual(published.length, 32, 'every open document is published'); +assert.strictEqual(published[31].params.uri, uri, 'a long uri is echoed without truncation'); +assert.ok(published.every(m => !m.params.diagnostics.some(d => d.severity === 1)), 'all documents check cleanly'); +const hover = responses.find(m => m.id === 2).result.contents; +assert.strictEqual(hover.kind, 'markdown'); +assert.match(hover.value, /^```zc\nint helper\(\)\n```\n\n/); +assert.ok(hover.value.includes('**formatted**')); +assert.ok(hover.value.includes('final documentation line'), 'hover documentation grows past its initial buffer'); +console.log('ok lsp grows beyond 16 documents, 160 uri bytes, and 2300 hover characters'); diff --git a/tests/drivers/lsp_live.js b/tests/drivers/lsp_live.js new file mode 100644 index 0000000..b5fe805 --- /dev/null +++ b/tests/drivers/lsp_live.js @@ -0,0 +1,23 @@ +// the native server must answer while the client keeps the pipe open and waits, as an editor +// does: one message in, the answer out, before anything else is sent. an output buffer that +// is only flushed at exit, or an end-of-input peek that waits for the next message, fails this. +// usage: node tests/drivers/lsp_live.js path/to/zclsp +const cp = require('child_process'); +const p = cp.spawn(process.argv[2], []); +let inbox = Buffer.alloc(0), step = 0, done = false; +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 finish = (ok, what) => { if (done) return; done = true; p.kill(); console.log((ok ? 'ok ' : 'FAIL ') + what); process.exit(ok ? 0 : 1); }; +const timer = setTimeout(() => finish(false, 'lsp live: no answer in 5 s while the pipe stayed open (step ' + step + ')'), 5000); +p.stdout.on('data', d => { + inbox = Buffer.concat([inbox, d]); + const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return; + const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10); + if (inbox.length < e + 4 + n) return; + const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString()); + inbox = inbox.slice(e + 4 + n); + if (step === 0 && m.id === 1) { + step = 1; // the answer came with the pipe still open: ask for something else + p.stdin.write(frame({ jsonrpc: '2.0', id: 2, method: 'shutdown', params: null })); + } else if (step === 1 && m.id === 2) { clearTimeout(timer); finish(true, 'lsp live: initialize and shutdown are answered while the pipe stays open'); } +}); +p.stdin.write(frame({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } })); diff --git a/tests/drivers/lsp_sandbox.js b/tests/drivers/lsp_sandbox.js new file mode 100644 index 0000000..14bc1e3 --- /dev/null +++ b/tests/drivers/lsp_sandbox.js @@ -0,0 +1,22 @@ +// opening a file in the editor checks it, and a check runs the file's compile-time code +// (immediate functions). the server must not let that code write files, so a file that +// tries to leaves nothing behind and the server still answers. +// usage: node tests/drivers/lsp_sandbox.js path/to/zclsp +const cp = require('child_process'), fs = require('fs'), os = require('os'), path = require('path'); +const target = path.join(os.tmpdir(), 'zc-sandbox-' + process.pid); +try { fs.unlinkSync(target); } catch (e) {} +const src = 'immediate fn evil() { let fd = syscall(1, "' + target + '", 1, 0); syscall(4, fd, 65, 1); syscall(2, fd, 0, 0); return 0; }\nevil\nfn main() { return 0; }\n'; +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 input = Buffer.concat([ + frame({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } }), + frame({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri: 'file:///evil.zc', languageId: 'zc', version: 1, text: src } } }), + frame({ jsonrpc: '2.0', id: 3, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri: 'file:///evil.zc' } } }), + frame({ jsonrpc: '2.0', method: 'exit' }), +]); +const r = cp.spawnSync(process.argv[2], [], { input, timeout: 20000 }); +const wrote = fs.existsSync(target); +if (wrote) fs.unlinkSync(target); +const answered = r.stdout && r.stdout.includes('"id":3'); +const ok = !wrote && answered; +console.log((ok ? 'ok ' : 'FAIL ') + 'lsp sandbox: compile-time code cannot write files' + (ok ? '' : ' (wrote: ' + wrote + ', answered: ' + !!answered + ')')); +process.exit(ok ? 0 : 1); diff --git a/tests/drivers/lsp_stream.js b/tests/drivers/lsp_stream.js new file mode 100644 index 0000000..0dd0553 --- /dev/null +++ b/tests/drivers/lsp_stream.js @@ -0,0 +1,11 @@ +// expose either extension server host as a stdin/stdout process for focused tests. +const fs = require('fs'); +const path = require('path'); +const target = path.resolve(process.argv[2]); +const { wasmProcess } = require('../../editors/vscode/client/wasmproc'); +const { vmProcess } = require('../../editors/vscode/client/vmproc'); +const server = target.endsWith('.wasm') ? wasmProcess(target) : vmProcess(target); +server.stdout.on('data', bytes => process.stdout.write(bytes)); +server.stderr.on('data', bytes => process.stderr.write(bytes)); +server.on('exit', status => { if (status !== 0) process.exitCode = 1; }); +server.stdin.write(fs.readFileSync(0)); diff --git a/tests/drivers/lsp_test.js b/tests/drivers/lsp_test.js new file mode 100644 index 0000000..a783e1e --- /dev/null +++ b/tests/drivers/lsp_test.js @@ -0,0 +1,246 @@ +// protocol tests for the language server (node, no packages). +// usage: node tests/drivers/lsp_test.js path/to/zclsp +const { spawnSync } = require('child_process'); +const fs = require('fs'); +const server = process.argv[2]; +let ok = 0, bad = 0; +function check(cond, label, extra) { + if (cond) { ok++; console.log('ok lsp ' + label); } + else { bad++; console.log('FAIL lsp ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra))); } +} +function frame(m) { + const b = Buffer.from(JSON.stringify(m), 'utf8'); + return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); +} +function parse(buf) { + const out = []; let i = 0; + while (i < buf.length) { + const j = buf.indexOf('\r\n\r\n', i); + if (j < 0) break; + const n = parseInt(/Content-Length: (\d+)/.exec(buf.slice(i, j).toString())[1], 10); + out.push(JSON.parse(buf.slice(j + 4, j + 4 + n).toString('utf8'))); + i = j + 4 + n; + } + return out; +} +function run(msgs) { + const r = spawnSync(server, [], { input: Buffer.concat(msgs.map(frame)), timeout: 30000, maxBuffer: 1 << 28 }); + return { code: r.status, msgs: parse(r.stdout) }; +} +const init = id => ({ jsonrpc: '2.0', id, method: 'initialize', params: {} }); +const open = (uri, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } }); +const change = (uri, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version: 2 }, contentChanges: [{ text }] } }); +const sem = (id, uri) => ({ jsonrpc: '2.0', id, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } }); +const diags = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && (!uri || m.params.uri === uri)); +const A = 'file:///a.zc', B2 = 'file:///b.zc'; + +// initialize: capabilities and the 12 type legend +let r = run([init(1), { jsonrpc: '2.0', method: 'exit' }]); +let res = r.msgs.find(m => m.id === 1); +check(res && res.result.capabilities.semanticTokensProvider.legend.tokenTypes.length === 12, 'initialize advertises the legend'); +check(res && res.result.capabilities.textDocumentSync.change === 1, 'initialize asks for full-text sync'); + +// a request before initialize is refused, and the id is echoed +r = run([{ jsonrpc: '2.0', id: 7, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri: A } } }]); +check(r.msgs.length === 1 && r.msgs[0].error && r.msgs[0].error.code === -32002 && r.msgs[0].id === 7, 'a request before initialize gets -32002'); + +// unknown methods: MethodNotFound with numeric and string ids, silence for notifications +r = run([init(1), { jsonrpc: '2.0', id: 'abc', method: 'workspace/nothing' }, { jsonrpc: '2.0', method: 'workspace/nothing' }]); +const nf = r.msgs.find(m => m.id === 'abc'); +check(nf && nf.error && nf.error.code === -32601, 'unknown request gets MethodNotFound, string id echoed', nf); +check(r.msgs.length === 2, 'an unknown notification is ignored'); + +// a clean program has no diagnostics +const good = 'fn main() {\n\tput_n(1 + 2);\n\treturn 0;\n}\n'; +r = run([init(1), open(A, good)]); +let d = diags(r.msgs, A); +check(d.length === 1 && d[0].params.diagnostics.length === 0, 'a clean program publishes an empty list', d); + +// an error lands on the right line and column +const bad1 = 'fn main() {\n\tlet x = 5\n\treturn x;\n}\n'; +r = run([init(1), open(A, bad1)]); +d = diags(r.msgs, A); +const e1 = d.length && d[0].params.diagnostics[0]; +check(e1 && e1.severity === 1 && e1.range.start.line === 1 && /expected ';', found 'return'/.test(e1.message), 'a missing semicolon is reported on its line', e1); + +// utf-16 columns: an emoji (two code units) and an accented letter before the error +const uni = '// café 😀\nfn main() { put_s("é😀"); return undefined_name; }\n'; +r = run([init(1), open(A, uni)]); +d = diags(r.msgs, A); +const e2 = d.length && d[0].params.diagnostics[0]; +const col = uni.split('\n')[1].indexOf('undefined_name'); +check(e2 && e2.range.start.line === 1 && e2.range.start.character === col, 'columns count utf-16 units', e2 && e2.range); + +// fixing the text through didChange clears the error +r = run([init(1), open(A, bad1), change(A, good)]); +d = diags(r.msgs, A); +check(d.length === 2 && d[0].params.diagnostics.length > 0 && d[1].params.diagnostics.length === 0, 'didChange re-checks the document'); + +// two documents do not leak into each other, and checks repeat the same way +r = run([init(1), open(A, bad1), open(B2, good), change(A, bad1)]); +const da = diags(r.msgs, A), db = diags(r.msgs, B2); +check(da.length === 2 && JSON.stringify(da[0].params.diagnostics) === JSON.stringify(da[1].params.diagnostics) && db[0].params.diagnostics.length === 0, 'documents are checked in isolation'); + +// syntax modifications made by the program itself apply to the check, like the compiler +const pipeDef = 'immediate fn pipe_op() { next(); add_binop("|>", 1, "c"); return 0; }\npipe_op\n'; +const pipeUse = 'fn double(x) { return x * 2; }\nfn main() { return 4 |> double; }\n'; +r = run([init(1), open(A, pipeDef + pipeUse), open(B2, pipeUse)]); +check(diags(r.msgs, A)[0].params.diagnostics.filter(x => x.severity === 1).length === 0, 'a parse word that adds an operator is understood'); +check(diags(r.msgs, B2)[0].params.diagnostics.filter(x => x.severity === 1).length > 0, 'the same program without the parse word is an error'); + +// semantic tokens: groups of five, keywords and functions classified from the compiler's own tables +r = run([init(1), open(A, good), sem(2, A)]); +res = r.msgs.find(m => m.id === 2); +const data = res && res.result && res.result.data; +check(data && data.length > 0 && data.length % 5 === 0, 'semantic tokens come in groups of five'); +check(data && data[3] === 0 && data[0] === 0 && data[1] === 0, 'fn is a keyword at 0:0', data && data.slice(0, 5)); +check(data && data[8] === 2, 'a function name is a function', data && data.slice(5, 10)); + +// decode the semantic tokens of a document into text:type pairs +function tokens(text) { + const rr = run([init(1), open(A, text), sem(2, A)]); + const dd = rr.msgs.find(m => m.id === 2).result.data; + const kinds = ['keyword', 'type', 'function', 'variable', 'string', 'number', 'operator', 'comment', 'parameter', 'property', 'macro', 'enumMember']; + const lines = text.split('\n'); let l = 0, c = 0; const out = []; + for (let i = 0; i < dd.length; i += 5) { + l += dd[i]; c = dd[i] ? dd[i + 1] : c + dd[i + 1]; + out.push(lines[l].substr(c, dd[i + 2]) + ':' + kinds[dd[i + 3]]); + } + return out; +} +const meth = 'struct point {\n\tlet x, y;\n\tfn sum() { return this.x + this.y; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum();\n}\n'; +const tk = tokens(meth); +check(tk.filter(t => t === 'sum:function').length === 2, 'a method is a function where it is declared and where it is called', tk); +check(tk.includes('this:parameter') && tk.includes('x:property'), 'this is a parameter and a field is a property', tk); +check(tk.filter(t => t === 'point:type').length >= 3, 'a user type is a type, also before a postfix star', tk); + +// a large document goes through the streaming reader +let big = ''; +for (let i = 0; i < 2500; i++) big += 'fn f' + i + '(a, b) { return a * b + ' + i + '; }\n'; +big += 'fn main() { return f0(1, 2); }\n'; +r = run([init(1), open(A, big)]); +d = diags(r.msgs, A); +check(d.length === 1 && d[0].params.diagnostics.filter(x => x.severity === 1).length === 0, 'a document of ' + big.length + ' bytes is checked', d.length); + +// local tables grow past their initial reservation, and the next document still checks +let many = 'fn main() {\n'; +for (let i = 0; i < 600; i++) many += '\tlet v' + i + ' = ' + i + ';\n'; +many += '\treturn 0;\n}\n'; +r = run([init(1), open(A, many), open(B2, good)]); +d = diags(r.msgs, A); +check(d.length === 1 && !d[0].params.diagnostics.some(x => x.severity === 1) && diags(r.msgs, B2).length === 1, 'locals grow past 512 and the server carries on', d.length); + +// hover: the text at a position, zero-based line and character, or null +function hover(text, line, ch) { + const rr = run([init(1), open(A, text), { jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri: A }, position: { line, character: ch } } }]); + const x = rr.msgs.find(m => m.id === 3); + return x && x.result ? x.result.contents.value : null; +} +const at = (text, line, word, nth) => { const s = text.split('\n')[line]; let i = -1; for (let k = 0; k <= (nth || 0); k++) i = s.indexOf(word, i + 1); return i; }; +const hsrc = '// adds two numbers\nint add(int a, int b) { return a + b; }\nint twice(int a) { return a * 2; }\nint main() {\n\tint n = add(1, 2);\n\tlet i = 3;\n\treturn twice(n) + i;\n}\n'; +let hv = hover(hsrc, 4, at(hsrc, 4, 'add')); +check(hv && hv.includes('int add(int a, int b)') && hv.includes('adds two numbers'), 'hover on a call shows the signature and the doc', hv); +check(hv && /^```zc\n/.test(hv) && /\n```\n\nadds two numbers/.test(hv), 'hover separates the code fence from Markdown documentation', hv); +const unicodeHover = 'fn main() { put_s("é😀"); put_c(10); return 0; }\n'; +hv = hover(unicodeHover, 0, at(unicodeHover, 0, 'put_c')); +check(hv && hv.includes('put_c('), 'hover converts UTF-16 columns after BMP and astral characters', hv); +hv = hover(hsrc, 0, hsrc.split('\n')[0].length + 10); +check(hv === null, 'an out-of-range hover column cannot select a name on the following line', hv); +hv = hover(hsrc, 6, at(hsrc, 6, 'twice')); +check(hv && hv.includes('int twice(int a)') && !hv.includes('adds two numbers'), 'a function with no doc still shows its signature', hv); +hv = hover(hsrc, 1, at(hsrc, 1, 'a', 2)); +check(hv && hv.includes('parameter') && hv.includes('int a'), 'hover on a parameter shows its declaration', hv); +hv = hover(hsrc, 5, at(hsrc, 5, 'i')); +check(hv && hv.includes('let i') && hv.includes('local'), 'hover on a local shows its declaration', hv); +hv = hover(hsrc, 6, at(hsrc, 6, 'i', 1)); +check(hv && hv.includes('let i') && hv.includes('local'), 'hover on a use of a local shows its declaration', hv); +const tsrc = 'fn main() {\n\tlet i = 3;\n\tlet p = new(int);\n\treturn i;\n}\n'; +// an untyped parameter and an untyped function show the types annotate gives them +const isrc = 'fn twice(x) { return x * 2; }\nfn main() {\n\tlet n = twice(4);\n\treturn n;\n}\n'; +let hi = hover(isrc, 0, 9); +check(hi && hi.includes('x // parameter; type int'), 'an untyped parameter shows its inferred type', hi); +hi = hover(isrc, 0, 3); +check(hi && hi.includes('int twice(int x)'), 'an untyped function shows its inferred parameter and return types', hi); +hv = hover(tsrc, 1, 5); +check(hv && hv.includes('type int'), 'an untyped number local shows the type annotate gives it', hv); +hv = hover(tsrc, 2, 5); +check(hv && hv.includes('type int*'), 'a pointer local shows its pointer type on its declaration line', hv); +hv = hover('fn main() {\n\tlet i = 3;\n\treturn i;\n}\n', 2, 8); +check(hv && hv.includes('let i'), 'a return of a local is a use, not a declaration', hv); +hv = hover(hsrc, 6, at(hsrc, 6, 'return')); +check(hv && hv.includes('leaves the function with a value'), 'a keyword shows what it does', hv); +hv = hover('fn main() {\n\tput_c(32);\n\treturn 0;\n}\n', 1, 1); +check(hv && hv.includes('put_c('), 'a built-in function shows its signature', hv); +const kwsrc = 'fn main() {\n\tint* p = new(int);\n\tfree(p);\n\treturn 0;\n}\n'; +hv = hover(kwsrc, 1, at(kwsrc, 1, 'new')); +check(hv && hv.includes('new(T)') && hv.includes('fresh object'), 'hover on new shows its form and what it does', hv); +hv = hover(kwsrc, 2, at(kwsrc, 2, 'free')); +check(hv && hv.includes('frees a heap object'), 'hover on free shows its doc', hv); +const kdoc = '// the number of lines\nfn main() {\n\treturn 0;\n}\n'; +hv = hover(kdoc, 2, 1); +check(hv === null || !hv.includes('number of lines'), 'a doc comment is not attached to a keyword in a body', hv); + +// a method of a struct is indented in the body, and its hover is still its line and doc +const msrc = 'struct point {\n\tlet x;\n\t// the sum of the parts\n\tfn sum() { return this.x; }\n\tstatic fn zero() { return 0; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum() + point.zero();\n}\n'; +hv = hover(msrc, 8, at(msrc, 8, 'sum')); +check(hv && hv.includes('fn sum()') && hv.includes('the sum of the parts'), 'a method called through a pointer shows its signature and doc', hv); +hv = hover(msrc, 8, at(msrc, 8, 'zero')); +check(hv && hv.includes('static fn zero()'), 'a static function of a struct shows its signature', hv); + +// a typed method shows its return type and parameters +const tmsrc = 'struct point {\n\tlet x;\n\t// the sum of the parts\n\tint sum(int k) { return this.x + k; }\n}\nfn main() {\n\tpoint* p = new(point);\n\treturn p.sum(1);\n}\n'; +hv = hover(tmsrc, 7, at(tmsrc, 7, 'sum')); +check(hv && hv.includes('int sum(int k)') && hv.includes('the sum of the parts'), 'a typed method shows its return type and parameters', hv); + +// externs are declarations, so they draw no "never reassigned" hint +const ext = 'extern double sqrt(double);\nextern double pow(double x, double y);\nfn main() {\n\treturn 0;\n}\n'; +r = run([init(1), open(A, ext)]); +d = diags(r.msgs, A); +check(d.length === 1 && !d[0].params.diagnostics.some(x => /never reassigned/.test(x.message)), 'an extern draws no hint about its stub', d.length && d[0].params.diagnostics); + +// shutdown and exit end the process cleanly +r = run([init(1), { jsonrpc: '2.0', id: 9, method: 'shutdown' }, { jsonrpc: '2.0', method: 'exit' }]); +check(r.code === 0 && r.msgs.some(m => m.id === 9 && m.result === null), 'shutdown then exit ends with status 0', r.code); + +// the corpus: every valid program checks clean, every bad one is rejected with its message +function cli(file) { + const r = spawnSync(server, [], { input: fs.readFileSync(file), timeout: 30000 }); + return r.stdout.toString(); +} +let clean = 0, dirty = []; +for (const dir of ['examples', 'tests/programs']) { + for (const f of fs.readdirSync(dir).filter(n => n.endsWith('.zc'))) { + if (f === 'manyerrors.zc' || f === 'undefined_call.zc' || f === 'zc0typed.zc') continue; // manyerrors and undefined_call are bad on purpose; zc0typed.zc is stage 0 syntax + const out = cli(dir + '/' + f); + if (/: error: /.test(out)) dirty.push(dir + '/' + f + ' ' + out.split('\n')[0]); else clean++; + } +} +check(dirty.length === 0, 'every example and test program checks clean (' + clean + ' files)', dirty); +let missed = [], n = 0; +for (const dir of ['errors', 'typeerrors', 'langerrors']) { + for (const f of fs.readdirSync('tests/' + dir).filter(x => x.endsWith('.zc'))) { + const want = fs.readFileSync('tests/' + dir + '/' + f, 'utf8').split(/\r?\n/)[0].replace('// expect: ', ''); + const out = cli('tests/' + dir + '/' + f); + n++; + if (!out.includes(want)) missed.push(dir + '/' + f + ' wanted [' + want + '] got [' + out.split('\n')[0] + ']'); + } +} +check(missed.length === 0, 'every bad program is rejected with the compiler\'s message (' + n + ' files)', missed); +const manyOut = cli('tests/programs/manyerrors.zc').split('\n').filter(l => /: error: /.test(l)); +check(manyOut.length === 4, 'several errors in one run are all reported', manyOut); + +// names resolve the way the compiler resolves them: a local or a parameter named +// like a built-in is that variable, and the built-in is only what the scope leaves +const scp = 'int cap = 2;\nfn grow(int cap) { return cap + 1; }\nfn main() {\n\tint cap = 3;\n\treturn len(grow(cap));\n}\n'; +const sct = tokens(scp); +check(sct.includes('cap:parameter') && sct.includes('cap:variable') && !sct.includes('cap:keyword') && !sct.includes('cap:function'), 'a name like a built-in is a variable or parameter where the scope says', sct); +check(sct.includes('len:keyword'), 'a built-in that is a keyword in the compiler is still a keyword', sct); +let hcv = hover(scp, 4, at(scp, 4, 'cap')); +check(hcv && hcv.includes('int cap') && hcv.includes('local'), 'hover on a use of a local named like a built-in shows the local', hcv); +hcv = hover(scp, 1, at(scp, 1, 'cap', 1)); +check(hcv && hcv.includes('parameter'), 'hover on a use of a parameter named like a built-in shows the parameter', hcv); +hcv = hover(scp, 4, at(scp, 4, 'len')); +check(hcv && hcv.includes('the number of items'), 'hover on the built-in still shows its text where no local shadows it', hcv); + +console.log(ok + ' lsp checks passed, ' + bad + ' failed'); +process.exit(bad ? 1 : 0); diff --git a/tests/drivers/lsp_vm.js b/tests/drivers/lsp_vm.js new file mode 100644 index 0000000..24c1a5b --- /dev/null +++ b/tests/drivers/lsp_vm.js @@ -0,0 +1,112 @@ +// tests for the language server run by the javascript vm (src/js/tinyvm.js), through +// the extension's own host (editors/vscode/client/vmproc.js): the same checks as +// tests/drivers/lsp_wasm.js. the vm starts at the image's heap and grows as the server asks. +// usage: node tests/drivers/lsp_vm.js path/to/server/dir (tinyvm.js, lsp.json, layout.js) +const path = require('path'); +const { vmProcess } = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'vmproc.js')); +const fs = require('fs'); +const dir = path.resolve(process.argv[2]); +let ok = 0, bad = 0; +function check(cond, label, extra) { + if (cond) { ok++; console.log('ok lsp vm ' + label); } + else { bad++; console.log('FAIL lsp vm ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra).slice(0, 300))); } +} +// runs one session: the messages are sent, and the answers collected by id +function session(docs) { + const replies = {}, notes = []; + const p = vmProcess(dir, { log: () => {} }); + const exited = { code: undefined }; + p.on('exit', c => { exited.code = c; }); + let inbox = Buffer.alloc(0); + p.stdout.on('data', d => { + inbox = Buffer.concat([inbox, d]); + for (;;) { + const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return; + const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10); + if (inbox.length < e + 4 + n) return; + const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString('utf8')); + inbox = inbox.slice(e + 4 + n); + if (m.id !== undefined) replies[m.id] = m; else notes.push(m); + } + }); + const send = m => { const b = Buffer.from(JSON.stringify(m), 'utf8'); p.stdin.write(Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b])); }; + send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } }); + send({ jsonrpc: '2.0', method: 'initialized', params: {} }); + for (const [uri, text] of docs) send({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } }); + return { p, replies, notes, send, exited }; +} +const clean = 'int main() {\n\tint x = 1;\n\treturn x;\n}\n'; +const bad_src = 'int main() {\n\tint x = 1\n\treturn x;\n}\n'; +const tokOf = (s, uri) => { + s.send({ jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } }); + s.send({ jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: 1, character: 9 } } }); + s.send({ jsonrpc: '2.0', id: 4, method: 'shutdown', params: null }); + s.send({ jsonrpc: '2.0', method: 'exit' }); +}; +const diagsOf = (s, uri) => s.notes.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri); + +// a clean program: initialize, no diagnostics, tokens, and it exits on its own +{ + const s = session([['file:///a.zc', clean]]); + tokOf(s, 'file:///a.zc'); + const init = s.replies[1]; + check(init && init.result.capabilities.semanticTokensProvider && init.result.capabilities.hoverProvider, 'initialize advertises tokens and hover', init); + check(diagsOf(s, 'file:///a.zc').length === 1 && diagsOf(s, 'file:///a.zc')[0].params.diagnostics.every(x => x.severity !== 1), 'a clean program has no errors (hints are fine)'); + const t = s.replies[2]; + check(t && t.result && t.result.data.length > 0 && t.result.data.length % 5 === 0, 'semantic tokens come back in groups of five', t && t.result && t.result.data.length); + check(s.replies[4] && s.replies[4].result === null, 'shutdown is answered'); + check(s.p.stdin.write(Buffer.alloc(0)) === false, 'the server has exited after exit'); +} +// a broken program: the compiler's own message is the diagnostic +{ + const s = session([['file:///b.zc', bad_src]]); + const d = diagsOf(s, 'file:///b.zc'); + check(d.length === 1 && d[0].params.diagnostics.length > 0, 'a missing semicolon gives a diagnostic'); + check(d.length === 1 && d[0].params.diagnostics.some(x => /expected/.test(x.message)), 'the message is the compiler\'s', d); + s.send({ jsonrpc: '2.0', method: 'exit' }); +} +// hover: a name the document declares, and a compiler name with docs in the image +{ + const src = '// adds one to its argument\nint inc(int x) { return x + 1; }\nint main() {\n\treturn inc(2);\n}\n'; + const s = session([['file:///c.zc', src]]); + s.send({ jsonrpc: '2.0', id: 5, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///c.zc' }, position: { line: 3, character: 9 } } }); + s.send({ jsonrpc: '2.0', method: 'exit' }); + const h = s.replies[5]; + check(h && h.result && /adds one/.test(h.result.contents.value), 'hover shows the comment above a declaration', h); + const s2 = session([['file:///d.zc', 'int main() {\n\tint z = docofs("x");\n\treturn 0;\n}\n']]); + s2.send({ jsonrpc: '2.0', id: 6, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///d.zc' }, position: { line: 1, character: 10 } } }); + s2.send({ jsonrpc: '2.0', method: 'exit' }); + const h2 = s2.replies[6]; + check(h2 && h2.result && /packed documentation/.test(h2.result.contents.value), 'hover shows the docs of a compiler name', h2); +} +// a document that is bigger than one feed: the input is split and comes out whole +{ + let big = 'int main() {\n'; + for (let i = 0; i < 4000; i++) big += '\tint v' + i + ' = ' + i + ';\n'; + big += '\treturn 0;\n}\n'; + const s = session([['file:///e.zc', big]]); + s.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s, 'file:///e.zc').length === 1, 'a document bigger than one feed is read whole (' + big.length + ' bytes)'); +} +// the regression: the server halted without an answer on any document that +// needed more memory than its first heap (examples/bf.zc, and a document twice +// the size of the earlier one). each must be checked and published, and the +// server must still be running until it is told to exit +{ + const bfPath = path.join(__dirname, '..', '..', 'examples', 'bf.zc'); + const bf = fs.readFileSync(bfPath, 'utf8'); + const s = session([['file:///bf.zc', bf]]); + s.send({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri: 'file:///bf.zc', version: 2 }, contentChanges: [{ text: bf }] } }); + s.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s, 'file:///bf.zc').length >= 1, 'examples/bf.zc is checked and published (' + bf.length + ' bytes)'); + check(s.exited.code === 0, 'the server runs until exit, then leaves with status 0', s.exited); + let huge = 'int main() {\n'; + for (let i = 0; i < 12000; i++) huge += '\tint h' + i + ' = ' + i + ' + ' + (i % 7) + ';\n'; + huge += '\treturn 0;\n}\n'; + const s2 = session([['file:///huge.zc', huge]]); + s2.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s2, 'file:///huge.zc').length === 1, 'a document past the first heap is checked and published (' + huge.length + ' bytes)', s2.exited); + check(s2.exited.code === 0, 'the big document leaves the server with status 0 after exit', s2.exited); +} +console.log(ok + ' lsp vm checks passed, ' + bad + ' failed'); +process.exit(bad ? 1 : 0); diff --git a/tests/drivers/lsp_wasm.js b/tests/drivers/lsp_wasm.js new file mode 100644 index 0000000..4ff2d16 --- /dev/null +++ b/tests/drivers/lsp_wasm.js @@ -0,0 +1,112 @@ +// tests for the language server as WebAssembly, through the extension's own +// host (editors/vscode/client/wasmproc.js). the same protocol checks as the +// native server, plus the hover docs of a compiler name. +// usage: node tests/drivers/lsp_wasm.js path/to/lsp.wasm +const path = require('path'); +const { wasmProcess } = require(path.join(__dirname, '..', '..', 'editors', 'vscode', 'client', 'wasmproc.js')); +const fs = require('fs'); +const wasm = process.argv[2]; +let ok = 0, bad = 0; +function check(cond, label, extra) { + if (cond) { ok++; console.log('ok lsp wasm ' + label); } + else { bad++; console.log('FAIL lsp wasm ' + label + (extra === undefined ? '' : ': ' + JSON.stringify(extra).slice(0, 300))); } +} +// runs one session: the messages are sent, and the answers collected by id +function session(docs) { + const replies = {}, notes = []; + const p = wasmProcess(wasm, { log: () => {} }); + const exited = { code: undefined }; + p.on('exit', c => { exited.code = c; }); + let inbox = Buffer.alloc(0); + p.stdout.on('data', d => { + inbox = Buffer.concat([inbox, d]); + for (;;) { + const e = inbox.indexOf('\r\n\r\n'); if (e < 0) return; + const n = parseInt(/Content-Length: (\d+)/.exec(inbox.slice(0, e).toString())[1], 10); + if (inbox.length < e + 4 + n) return; + const m = JSON.parse(inbox.slice(e + 4, e + 4 + n).toString('utf8')); + inbox = inbox.slice(e + 4 + n); + if (m.id !== undefined) replies[m.id] = m; else notes.push(m); + } + }); + const send = m => { const b = Buffer.from(JSON.stringify(m), 'utf8'); p.stdin.write(Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b])); }; + send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { processId: 1, capabilities: {} } }); + send({ jsonrpc: '2.0', method: 'initialized', params: {} }); + for (const [uri, text] of docs) send({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, languageId: 'zc', version: 1, text } } }); + return { p, replies, notes, send, exited }; +} +const clean = 'int main() {\n\tint x = 1;\n\treturn x;\n}\n'; +const bad_src = 'int main() {\n\tint x = 1\n\treturn x;\n}\n'; +const tokOf = (s, uri) => { + s.send({ jsonrpc: '2.0', id: 2, method: 'textDocument/semanticTokens/full', params: { textDocument: { uri } } }); + s.send({ jsonrpc: '2.0', id: 3, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: 1, character: 9 } } }); + s.send({ jsonrpc: '2.0', id: 4, method: 'shutdown', params: null }); + s.send({ jsonrpc: '2.0', method: 'exit' }); +}; +const diagsOf = (s, uri) => s.notes.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri); + +// a clean program: initialize, no diagnostics, tokens, and it exits on its own +{ + const s = session([['file:///a.zc', clean]]); + tokOf(s, 'file:///a.zc'); + const init = s.replies[1]; + check(init && init.result.capabilities.semanticTokensProvider && init.result.capabilities.hoverProvider, 'initialize advertises tokens and hover', init); + check(diagsOf(s, 'file:///a.zc').length === 1 && diagsOf(s, 'file:///a.zc')[0].params.diagnostics.every(x => x.severity !== 1), 'a clean program has no errors (hints are fine)'); + const t = s.replies[2]; + check(t && t.result && t.result.data.length > 0 && t.result.data.length % 5 === 0, 'semantic tokens come back in groups of five', t && t.result && t.result.data.length); + check(s.replies[4] && s.replies[4].result === null, 'shutdown is answered'); + check(s.p.stdin.write(Buffer.alloc(0)) === false, 'the server has exited after exit'); +} +// a broken program: the compiler's own message is the diagnostic +{ + const s = session([['file:///b.zc', bad_src]]); + const d = diagsOf(s, 'file:///b.zc'); + check(d.length === 1 && d[0].params.diagnostics.length > 0, 'a missing semicolon gives a diagnostic'); + check(d.length === 1 && d[0].params.diagnostics.some(x => /expected/.test(x.message)), 'the message is the compiler\'s', d); + s.send({ jsonrpc: '2.0', method: 'exit' }); +} +// hover: a name the document declares, and a compiler name with docs in the image +{ + const src = '// adds one to its argument\nint inc(int x) { return x + 1; }\nint main() {\n\treturn inc(2);\n}\n'; + const s = session([['file:///c.zc', src]]); + s.send({ jsonrpc: '2.0', id: 5, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///c.zc' }, position: { line: 3, character: 9 } } }); + s.send({ jsonrpc: '2.0', method: 'exit' }); + const h = s.replies[5]; + check(h && h.result && /adds one/.test(h.result.contents.value), 'hover shows the comment above a declaration', h); + const s2 = session([['file:///d.zc', 'int main() {\n\tint z = docofs("x");\n\treturn 0;\n}\n']]); + s2.send({ jsonrpc: '2.0', id: 6, method: 'textDocument/hover', params: { textDocument: { uri: 'file:///d.zc' }, position: { line: 1, character: 10 } } }); + s2.send({ jsonrpc: '2.0', method: 'exit' }); + const h2 = s2.replies[6]; + check(h2 && h2.result && /packed documentation/.test(h2.result.contents.value), 'hover shows the docs of a compiler name', h2); +} +// a document that is bigger than one feed: the input is split and comes out whole +{ + let big = 'int main() {\n'; + for (let i = 0; i < 4000; i++) big += '\tint v' + i + ' = ' + i + ';\n'; + big += '\treturn 0;\n}\n'; + const s = session([['file:///e.zc', big]]); + s.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s, 'file:///e.zc').length === 1, 'a document bigger than one feed is read whole (' + big.length + ' bytes)'); +} +// the regression: the server halted without an answer on any document that +// needed more memory than its first heap (examples/bf.zc, and a document twice +// the size of the earlier one). each must be checked and published, and the +// server must still be running until it is told to exit +{ + const bfPath = path.join(__dirname, '..', '..', 'examples', 'bf.zc'); + const bf = fs.readFileSync(bfPath, 'utf8'); + const s = session([['file:///bf.zc', bf]]); + s.send({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri: 'file:///bf.zc', version: 2 }, contentChanges: [{ text: bf }] } }); + s.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s, 'file:///bf.zc').length >= 1, 'examples/bf.zc is checked and published (' + bf.length + ' bytes)'); + check(s.exited.code === 0, 'the server runs until exit, then leaves with status 0', s.exited); + let huge = 'int main() {\n'; + for (let i = 0; i < 12000; i++) huge += '\tint h' + i + ' = ' + i + ' + ' + (i % 7) + ';\n'; + huge += '\treturn 0;\n}\n'; + const s2 = session([['file:///huge.zc', huge]]); + s2.send({ jsonrpc: '2.0', method: 'exit' }); + check(diagsOf(s2, 'file:///huge.zc').length === 1, 'a document past the first heap is checked and published (' + huge.length + ' bytes)', s2.exited); + check(s2.exited.code === 0, 'the big document leaves the server with status 0 after exit', s2.exited); +} +console.log(ok + ' lsp wasm checks passed, ' + bad + ' failed'); +process.exit(bad ? 1 : 0); diff --git a/tests/drivers/memory_limits_test.py b/tests/drivers/memory_limits_test.py new file mode 100644 index 0000000..a973480 --- /dev/null +++ b/tests/drivers/memory_limits_test.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# focused host memory configuration and growth checks. +import os +import subprocess + +source = '''fn main() { + int initial = syscall(9, 0, 0, 0); + put_n(syscall(9, 5, initial, 0) == initial); put_c(32); + put_n(syscall(9, 4, initial + 4096, 0) == -1); put_c(32); + put_n(syscall(9, 5, initial + 8192, 0) == initial + 8192); put_c(32); + put_n(syscall(9, 4, initial + 4096, 0) == initial + 4096); put_c(32); + put_n(syscall(9, 5, initial - 1, 0) == -1); put_c(10); + return 0; +} +''' +commands = [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']] +environment = dict(os.environ, TINYVM_MAX_MEMORY_WORDS='16777216') +for command in commands: + result = subprocess.run(command, input=source, text=True, capture_output=True, env=environment, timeout=15) + assert result.returncode == 0 and result.stdout == '1 1 1 1 1\n', (command, result.stdout, result.stderr) + invalid = subprocess.run(command, input=source, text=True, capture_output=True, env=dict(environment, TINYVM_MEMORY_WORDS='1'), timeout=15) + assert invalid.returncode != 0 and invalid.stderr, (command, invalid.stdout) + print('ok runtime memory limits, denied growth, successful growth, and invalid startup: ' + command[0]) diff --git a/tests/drivers/parser_growth_test.py b/tests/drivers/parser_growth_test.py new file mode 100644 index 0000000..4cbfbb2 --- /dev/null +++ b/tests/drivers/parser_growth_test.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +# parser storage grows across enum members, tagged enums, methods, and generated text. +import subprocess +import sys + +command = sys.argv[1:] + + +def run(source, expected): + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=30) + assert result.returncode == 0, (result.stdout, result.stderr) + assert result.stdout == expected, result.stdout[:1000] + + +source = 'enum values { ' + ', '.join(f'member_{i}' for i in range(300)) + ' };\n' +source += 'fn main() { gc(); put_n(member_299); put_c(10); return 0; }\n' +run(source, '299\n') +source = ''.join(f'enum tagged_{i} {{ item_{i} {{ int value; }}, empty_{i} }};\n' for i in range(25)) +source += 'fn main() { tagged_24*.m item = tagged_24.item_24(7); gc(); put_n(item.item_24_value); put_c(10); return 0; }\n' +run(source, '7\n') +source = 'struct methods { int value;\n' +source += ''.join(f'int get_{i}() {{ return this.value + {i}; }}\n' for i in range(100)) +source += '}\nfn main() { methods item; item.value = 7; gc(); put_n(item.get_99()); put_c(10); return 0; }\n' +run(source, '106\n') +source = 'enum expanded {\n' +source += ',\n'.join(f'member_with_long_generated_name_{i} {{ ' + ''.join(f'int field_with_long_generated_name_{j}; ' for j in range(8)) + '}' for i in range(40)) +source += '\n};\nfn main() { gc(); put_n(ebcap > 8192); put_c(10); return 0; }\n' +run(source, '1\n') +source = 'fn main() { int result = 0; switch (127) {\n' +source += ''.join(f'case {i}: result = {i};\n' for i in range(128)) +source += '} gc(); put_n(result); put_c(32); put_n(jpscap > 64); put_c(10); return 0; }\n' +run(source, '127 1\n') +source = 'fn main() { int result = 0;\n' +source += ''.join('o3 { result += 1; }\n' for _ in range(40)) +source += 'gc(); put_n(result); put_c(32); put_n(o3pendcap > 10); put_c(10); return 0; }\n' +run(source, '40 1\n') +source = 'fn main() { int i = 0; while (i < 120) { putfact(i, i, 1); i++; } gc(); put_n(factcap > 32); put_c(32); put_n(getlo(119)); put_c(10); return 0; }\n' +run(source, '1 119\n') +long_type = 'structure_' + 't' * 180 +long_method = 'method_' + 'm' * 180 +source = f'struct {long_type} {{ int {long_method}() {{ return 7; }} }};\n' +source += f'fn main() {{ {long_type} value; put_n(value.{long_method}()); put_c(10); return 0; }}\n' +run(source, '7\n') +name = 'generic_' + 'g' * 180 +source = f'int {name}_one<T>() {{ return sizeof(T); }}\nint {name}_two<T>() {{ return sizeof(T) + 1; }}\n' +source += f'fn main() {{ put_n({name}_one<int>() + {name}_two<int>()); put_c(10); return 0; }}\n' +run(source, '3\n') +print('ok parser tables, analyzer paths, queued regions, and generated names grow') diff --git a/tests/drivers/protocol_growth_test.js b/tests/drivers/protocol_growth_test.js new file mode 100644 index 0000000..64015d8 --- /dev/null +++ b/tests/drivers/protocol_growth_test.js @@ -0,0 +1,34 @@ +// preserve long request identifiers and ignore deeply nested unknown json fields. +const assert = require('assert'); +const cp = require('child_process'); +const target = process.argv[2]; +const id = 'request_' + 'x'.repeat(500); +let nested = { ['unknown_' + 'y'.repeat(100)]: 1 }; +for (let i = 0; i < 40; i++) nested = { child: nested }; +const frame = message => { + const body = Buffer.from(JSON.stringify(message)); + return Buffer.concat([Buffer.from('Content-Length: ' + body.length + '\r\nX-Extra: ' + 'z'.repeat(500) + '\r\n\r\n'), body]); +}; +const messages = [{ jsonrpc: '2.0', id, method: 'initialize', extra: nested, params: {} }]; +for (let i = 0; i < 24; i++) messages.push({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { + uri: 'file:///enum_' + i + '.zc', version: 1, languageId: 'zc', + text: 'enum choice { item { int value; }, empty };\nfn main() { choice*.m p = choice.item(7); return p.item_value; }\n', +} } }); +messages.push({ jsonrpc: '2.0', id: 'finish', method: 'shutdown', params: null }, { jsonrpc: '2.0', method: 'exit' }); +const result = cp.spawnSync(target, [], { input: Buffer.concat(messages.map(frame)), timeout: 20000, maxBuffer: 8 << 20 }); +assert.strictEqual(result.status, 0, String(result.stderr)); +const responses = []; +let data = result.stdout; +while (data.length) { + const end = data.indexOf('\r\n\r\n'); + assert.ok(end >= 0); + const length = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]); + responses.push(JSON.parse(data.subarray(end + 4, end + 4 + length).toString())); + data = data.subarray(end + 4 + length); +} +assert.ok(responses.some(message => message.id === id && message.result.capabilities), 'the full request id is echoed'); +assert.ok(responses.some(message => message.id === 'finish'), 'the next request is parsed'); +const diagnostics = responses.filter(message => message.method === 'textDocument/publishDiagnostics'); +assert.strictEqual(diagnostics.length, 24); +assert.ok(diagnostics.every(message => !message.params.diagnostics.some(diagnostic => diagnostic.severity === 1)), JSON.stringify(diagnostics)); +console.log('ok long protocol fields, deep json, and tagged enums across document checks'); diff --git a/tests/drivers/seed_growth_test.py b/tests/drivers/seed_growth_test.py new file mode 100644 index 0000000..426c970 --- /dev/null +++ b/tests/drivers/seed_growth_test.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +# stage 0 accepts long source streams and grows a tiny initial image reservation. +import pathlib +import subprocess +import tempfile + +root = pathlib.Path(__file__).resolve().parents[2] +with tempfile.TemporaryDirectory(prefix='seed-growth-', dir=root / 'build') as directory: + folder = pathlib.Path(directory) + subprocess.run(['bin/genmap', '--preset', 'run', '--grow', '--genome', '600000', '--heap', '1048576', '-o', directory], check=True, capture_output=True) + compiler = folder / 'zc0' + subprocess.run(['cc', '-O1', '-w', '-fwrapv', '-DMAXW=16', 'src/tools/zc0.c', '-I' + directory, '-Isrc/core', '-o', str(compiler)], check=True) + source = '/*' + 'x' * (5 << 20) + '*/\n' + source += (folder / 'rt.zc').read_text() + (root / 'src/runtime/run.zc').read_text() + source += 'let data[550000]; fn main() { data[549999] = 7; put_n(data[549999]); put_c(32); put_n(4611686018427387904); put_c(10); return 0; }\n' + with (folder / 'genome.h').open('w') as output: + subprocess.run([str(compiler)], input=source, text=True, stdout=output, check=True, timeout=30) + binary = folder / 'vm' + import shutil + for path in ['src/micro/micro.c', 'src/micro/micro_port.h', 'src/micro/port_linux.c', 'src/core/fops.h', 'src/core/bops.h', 'src/core/stack.h']: + shutil.copy(root / path, folder) + subprocess.run(['cc', '-O2', '-w', '-fwrapv', str(folder / 'micro.c'), str(folder / 'port_linux.c'), '-I' + directory, '-o', str(binary)], check=True) + result = subprocess.run([str(binary)], text=True, capture_output=True, timeout=20) + assert result.returncode == 0 and result.stdout == '7 4611686018427387904\n', (result.returncode, result.stdout, result.stderr) +print('ok stage 0 reads beyond four megabytes and grows beyond its initial image capacity') diff --git a/tests/drivers/stack_growth_test.py b/tests/drivers/stack_growth_test.py new file mode 100644 index 0000000..d4abe81 --- /dev/null +++ b/tests/drivers/stack_growth_test.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +# operand values and return addresses survive explicit and automatic growth. +import subprocess +import sys +import tempfile +from pathlib import Path + +command = sys.argv[1:] + + +def run(source, expected, compile_image=False): + if compile_image and command[0] == 'node': + # compile the execution stress cases once with stage 0, so a javascript + # compiler's speed does not determine the execution-test timeout. + with tempfile.TemporaryDirectory(prefix='stack-image-', dir='build') as directory: + target = Path(directory) + subprocess.run(['bin/genmap', '--preset', 'run', '--grow', '--heap', '1048576', '--genome', '131072', '--frame', '4096', '--return', '256', '--data', '3072', '-o', directory], check=True, capture_output=True) + compiler = target / 'zc0' + subprocess.run(['cc', '-O1', '-w', '-fwrapv', 'src/tools/zc0.c', '-I' + directory, '-Isrc/core', '-o', str(compiler)], check=True, capture_output=True) + full_source = (target / 'rt.zc').read_text() + Path('src/runtime/run.zc').read_text() + source + image = subprocess.run([str(compiler)], input=full_source, text=True, capture_output=True, check=True) + header = target / 'genome.h' + header.write_text(image.stdout) + result = subprocess.run(['node', 'tests/drivers/image_run.js', str(header), str(target / 'memmap.h')], text=True, capture_output=True, timeout=45) + else: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=45) + assert result.returncode == 0 and result.stdout == expected, (command, result.returncode, result.stdout, result.stderr) + + +run('''fn main() { + int old_data = data_top - data_low, old_return = return_top - return_low; + put_n(reserve_data(old_data + 1) > old_data); put_c(32); + put_n(reserve_returns(old_return + 1) > old_return); put_c(32); + gc(); put_n(data_node != 0 && return_node != 0); put_c(10); return 0; +} +''', '1 1 1\n') + +run('''fn main() { + put_n(reserve_data(-1) == -1); put_c(32); put_n(reserve_returns(-1) == -1); put_c(32); + put_n(syscall(9, 6, 0, 0) == -1); put_c(32); + int current = syscall(9, 0, 0, 0); syscall(9, 5, current, 0); + put_n(reserve_data(0x10000000) == -1); put_c(32); gc(); put_n(7); put_c(10); return 0; +} +''', '1 1 1 1 7\n') + +count = 40000 +source = 'fn main() { int total = asm { ' + ' '.join(str(i + 1) for i in range(count)) +source += ' + ' * (count - 1) + ' }; gc(); put_n(total); put_c(32); ' +source += 'put_n(data_node != 0); put_c(10); return 0; }\n' +run(source, '800020000 1\n', compile_image=True) + +run('''unchecked int descend(int n) { + if (!n) { gc(); return 7; } + return descend(n - 1) + 1; +} +fn main() { put_n(descend(70000)); put_c(32); put_n(return_node != 0); put_c(10); return 0; } +''', '70007 1\n', compile_image=True) +print('ok explicit reservation, 40000 operands, and 70000 return addresses: ' + command[0]) diff --git a/tests/drivers/storage_analysis_test.js b/tests/drivers/storage_analysis_test.js new file mode 100644 index 0000000..da967f5 --- /dev/null +++ b/tests/drivers/storage_analysis_test.js @@ -0,0 +1,71 @@ +// definite storage findings use the compiler's parser and the editor protocol. +const assert = require('assert'); +const cp = require('child_process'); +const server = process.argv[2]; +function check(text, needle) { + const uri = 'file:///storage-analysis.zc'; + const messages = [{ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }, + { jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version: 1, text } } }]; + if (needle) { + const at = text.lastIndexOf(needle), before = text.slice(0, at); + assert.ok(at >= 0); + messages.push({ jsonrpc: '2.0', id: 2, method: 'textDocument/hover', params: { textDocument: { uri }, position: { line: before.split('\n').length - 1, character: before.length - before.lastIndexOf('\n') - 1 } } }); + } + messages.push({ jsonrpc: '2.0', method: 'exit' }); + const input = Buffer.concat(messages.map(m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); })); + const r = cp.spawnSync(server, process.argv.slice(3), { input, timeout: 20000, maxBuffer: 8 << 20 }); + assert.strictEqual(r.status, 0, String(r.stderr)); + const replies = []; let data = r.stdout; + while (data.length) { + const end = data.indexOf('\r\n\r\n'); assert.ok(end >= 0); + const n = Number(/Content-Length:\s*(\d+)/i.exec(data.subarray(0, end).toString())[1]); + replies.push(JSON.parse(data.subarray(end + 4, end + 4 + n))); + data = data.subarray(end + 4 + n); + } + const diagnostics = replies.find(m => m.method === 'textDocument/publishDiagnostics').params.diagnostics; + return { diagnostics, warnings: diagnostics.filter(d => d.severity === 2), hover: replies.find(m => m.id === 2)?.result?.contents?.value }; +} +const prefix = 'unchecked fn main() {\n'; +for (const [type, length] of [['int', 3], ['u8', 3], ['fixed []int', 3], ['[]u8', 3]]) { + const r = check(prefix + ` let p = new(${type}, ${length});\n let alias = p;\n return alias[${length}];\n}\n`, 'alias['); + assert.strictEqual(r.warnings.length, 1, JSON.stringify(r.diagnostics)); + assert.match(r.warnings[0].message, /out-of-bounds.*index 3.*length 3/); + assert.match(r.hover, /size: 3 elements.*lifetime: heap storage; live here/); + assert.strictEqual(r.warnings[0].range.start.line, 3); +} +const negative = check(prefix + ' let p = new(3); return p[-1];\n}\n'); +assert.match(negative.warnings[0]?.message || '', /index -1.*length 3/); +const freed = check(prefix + ' let p = new(int, 3);\n let q = p;\n free(p);\n return q[0];\n}\n', 'q['); +assert.strictEqual(freed.warnings.length, 1, JSON.stringify(freed.diagnostics)); +assert.match(freed.warnings[0].message, /use after free.*line 4/); +assert.match(freed.hover, /size: 3 elements.*lifetime: ended on line 4/); +const dereference = check(prefix + ' let p = new(int); free(p); return *p;\n}\n'); +assert.match(dereference.warnings[0]?.message || '', /use after free/); +const field = check('struct item { int value; };\n' + prefix + ' let p = new(item); free(p); return p.value;\n}\n'); +assert.match(field.warnings[0]?.message || '', /use after free/); +const scope = check(prefix + ' int* p;\n { let a[3]; p = a; }\n return p[0];\n}\n', 'p['); +assert.match(scope.warnings[0]?.message || '', /use after free.*line 3/); +assert.match(scope.hover, /lifetime: ended on line 3/); +const safe = [ + prefix + ' let p = new(int, 3); let q = p as u8*; return q[23]; }', + prefix + ' let p = new(int, 3); let q = (u8*)p; return q[23]; }', + prefix + ' int n = 2; let p = &n; let q = n; return q[2]; }', + prefix + ' let p = new(int, 3); let ignored = 0 && free(p); return p[0]; }', + prefix + ' let p = new(int, 3); let ignored = 1 || free(p); return p[0]; }', + prefix + ' let p = new(int, 50); return p[(u8)300]; }', + prefix + ' let p = new(int, 50); return p[300 as u8]; }', + prefix + ' let p = new(int, 3); let q = p; q[2] = 7; free(p); return 0; }', + prefix + ' let p = new(3); free(p); p = new(3); return p[0]; }', + 'fn unknown(int* p) {}\n' + prefix + ' let p = new(int, 3); unknown(p); return p[9]; }', + 'fn maybe(int n) { return n; }\n' + prefix + ' let p = new(int, 3); return p[maybe(9)]; }', + prefix + ' let p = new(int, 3); if (1) free(p); return p[0]; }', + prefix + ' let p = new(int, 3); while (0) free(p); return p[0]; }', + prefix + ' let p = new(int, 3); let f = fn() { free(p); return 0; }; return p[0]; }', + prefix + ' let p = new([]int, 0); push(p, 9); return p[0]; }', +]; +for (const source of safe) assert.deepStrictEqual(check(source).warnings, [], source); +const unknown = check('int read(int* p) { return p[0]; }\nfn main() { int n = 1; return read(&n); }\n', 'p['); +assert.match(unknown.hover, /size: unknown.*lifetime: unknown/); +const stack = check('fn main() { let a[3]; return a[2]; }\n', 'a['); +assert.match(stack.hover, /size: 3 elements.*lifetime: stack storage/); +console.log('ok definite bounds, free and scope lifetimes, alias hovers, and conservative unknown cases'); diff --git a/tests/drivers/vscode_hover_test.js b/tests/drivers/vscode_hover_test.js new file mode 100644 index 0000000..378dda2 --- /dev/null +++ b/tests/drivers/vscode_hover_test.js @@ -0,0 +1,48 @@ +// run inside a vscode extension test host to check the real hover api objects. +const assert = require('assert'); +const fs = require('fs'); +const path = require('path'); +const vscode = require('vscode'); +exports.run = async () => { + const root = path.resolve(__dirname, '..', '..'); + const fixture = path.join(root, 'build', 'review', 'hover-fixture.zc'); + fs.mkdirSync(path.dirname(fixture), { recursive: true }); + fs.writeFileSync(fixture, '// adds **two** numbers with `integer` arithmetic.\nint add(int a, int b) { return a + b; }\nfn main() { return add(1, 2); }\n'); + const extension = vscode.extensions.getExtension('tinyvm.zc-language-support'); + assert.ok(extension, 'development extension is loaded'); + const doc = await vscode.workspace.openTextDocument(fixture); + await vscode.window.showTextDocument(doc); + await extension.activate(); + let hover; + for (let attempt = 0; attempt < 100; attempt++) { + const replies = await vscode.commands.executeCommand('vscode.executeHoverProvider', doc.uri, new vscode.Position(2, 19)); + hover = replies && replies.find(reply => reply.contents.some(md => md.value.includes('adds **two** numbers'))); + if (hover) break; + await new Promise(resolve => setTimeout(resolve, 100)); + } + assert.ok(hover, 'real vscode provider returns declaration documentation'); + const md = hover.contents[0]; + assert.ok(md instanceof vscode.MarkdownString, 'hover contains a real MarkdownString'); + assert.match(md.value, /^```zc\nint add\(int a, int b\)\n```\n\n/); + assert.ok(md.value.includes('**two**') && md.value.includes('`integer`')); + assert.strictEqual(md.isTrusted, false); + const storageFile = path.join(root, 'build', 'review', 'hover-storage.zc'); + fs.writeFileSync(storageFile, 'unchecked fn main() {\n let p = new(int, 3);\n let /* borrowed array */ q = p;\n free(p);\n return q[0];\n}\n'); + const storageDoc = await vscode.workspace.openTextDocument(storageFile); + await vscode.window.showTextDocument(storageDoc); + let storageHover; + for (let attempt = 0; attempt < 100; attempt++) { + const replies = await vscode.commands.executeCommand('vscode.executeHoverProvider', storageDoc.uri, new vscode.Position(4, 8)); + storageHover = replies && replies.find(reply => reply.contents.some(md => md.value.includes('size: 3 elements'))); + if (storageHover) break; + await new Promise(resolve => setTimeout(resolve, 100)); + } + assert.ok(storageHover, 'real editor returns storage metadata'); + const storageMd = storageHover.contents[0]; + assert.ok(storageMd instanceof vscode.MarkdownString); + assert.match(storageMd.value, /borrowed array/); + assert.match(storageMd.value, /lifetime: ended on line 4/); + const result = 'ok real vscode markdown, code fences, block docs, inferred pointer types, and lifetime metadata\n'; + fs.writeFileSync(path.join(root, 'build', 'review', 'vscode-hover.log'), result); + console.log(result.trim()); +}; diff --git a/tests/drivers/wasm_test.js b/tests/drivers/wasm_test.js new file mode 100644 index 0000000..ddab3be --- /dev/null +++ b/tests/drivers/wasm_test.js @@ -0,0 +1,28 @@ +// runs programs on the webassembly build (src/web/zc.wasm) and compares with the expected output. +// usage: node tests/drivers/wasm_test.js [path/to/zc.wasm] +const fs = require('fs'); +const ZC = require('../../src/web/zc.js'); +(async () => { + const zc = await ZC.load(fs.readFileSync(process.argv[2] || __dirname + '/../../src/web/zc.wasm')); + const cases = [ + ['examples/hello.zc', 'hello, world!'], + ['examples/fact.zc', '1101110101111100000000\n3628800\n'], + ['examples/selfpatch.zc', 'ABC'], + ['examples/lists.zc', '[0 1 4 9 16 25]\nlive: 7\nafter the block: 0\n'], + ['examples/wiring.zc', '16 1234 25 4/9'], + ['examples/struct_closure_opt.zc', '299\n'], + ['examples/opt_test.zc', '1303\n'], + ['tests/programs/basics.zc', '285 610 42 512\nhey 65 -3 -2 1024 -8\n12456\n757\n9 100-101\n5\nok\n'], + ]; + let ok = 0, bad = 0; + for (const [file, want] of cases) { + const r = await zc.run(fs.readFileSync(__dirname + '/../../' + file, 'utf8')); + if (r.output.replace(/\n+$/, '') === want.replace(/\n+$/, '')) { ok++; console.log('ok wasm ' + file); } + else { bad++; console.log('FAIL wasm ' + file + ': got ' + JSON.stringify(r.output) + ' ' + r.messages); } + } + // an error is reported the way the interpreter reports it + const r = await zc.run('fn main() { return undefined_name; }'); + if (/undefined_name/.test(r.output)) { ok++; console.log('ok wasm compiler errors'); } else { bad++; console.log('FAIL wasm compiler errors: ' + JSON.stringify(r.output)); } + console.log(ok + ' wasm checks passed, ' + bad + ' failed'); + process.exit(bad ? 1 : 0); +})(); diff --git a/tests/drivers/word_literals_test.py b/tests/drivers/word_literals_test.py new file mode 100644 index 0000000..a2d230d --- /dev/null +++ b/tests/drivers/word_literals_test.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python3 +# every 64-bit word is representable, even outside a single literal's 63-bit range. +import subprocess + +values = [0, 1, (1 << 62) - 1, 1 << 62, (1 << 63) - 1, -(1 << 62), -(1 << 62) - 1, -(1 << 63), -1] +source = 'fn main() {\n' + ''.join(f'put_n({value}); put_c(10);\n' for value in values) + 'return 0; }\n' +expected = ''.join(str(value) + '\n' for value in values) +for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=20) + assert result.returncode == 0 and result.stdout == expected, (command, result.stdout, result.stderr) + print('ok full-width positive and negative word literals: ' + command[0]) +source = '''immediate fn add_word_operator() { next(); add_binop("**", 11, "4611686018427387904 | +"); return 0; } +add_word_operator +fn main() { put_n(0 ** 0); put_c(10); return 0; } +''' +for command in [['bin/zy'], ['bin/zym'], ['node', 'src/js/tinyvm.js']]: + result = subprocess.run(command, input=source, text=True, capture_output=True, timeout=20) + assert result.returncode == 0 and result.stdout == '4611686018427387904\n', (command, result.stdout, result.stderr) + print('ok full-width word in a stored operator sequence: ' + command[0]) |