git » fjorth.git » master » tree

[master] / fjorth.html 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
<!doctype html>
<html>
<head>
  <meta charset="utf-8" />
  <title>Fjorth — QUnit Tests</title>
  <!-- Prefer local QUnit assets to avoid network prompts; if unavailable, swap to CDN manually -->
  <link rel="stylesheet" href="qunit.css">
</head>
<body>
  <div id="qunit"></div>
  <div id="qunit-fixture"></div>

  <!-- Interpreter (callback errors) -->
  <script src="fjorth.js"></script>

  <!-- QUnit (local preferred) -->
  <script id="qunit-js" src="qunit.js"></script>

  <!-- Tests (ported to QUnit) -->
  <script src="test.js"> </script>

  <!-- Prefer local QUnit script; provide CDN fallback comment if needed -->
  <!-- If local qunit.js isn't available in your environment, replace the line above with:
  <script id="qunit-js" src="https://app.unpkg.com/qunit@2.24.1/files/qunit/qunit.js"></script>
  -->
  <!-- Additional tests: Structured Error Handling -->
  <script>
  (function(){
    function runCodeExpectErr(code, vmOpts={}) {
      return new Promise((resolve) => {
        const seen=[];
        const vm = new Fjorth(Object.assign({ onError: e => seen.push(e), stepBudget: 2000, sliceMs: 0 }, vmOpts));
        try {
          vm.reset();
          vm.load(code);
          vm.run((err) => {
            resolve({ vm, err, seen });
          });
        } catch (e) {
          resolve({ vm, err: e, seen: [...seen, e] });
        }
      });
    }

    function startErrTests(){
      QUnit.module('Structured Error Handling (callback API)');

      QUnit.test('undefined word: onError + idle get same Error with rich fields', async assert => {
        const { vm, err, seen } = await runCodeExpectErr('NOPE');
        assert.ok(err instanceof Error, 'idle callback receives Error');
        assert.strictEqual(seen.length, 1, 'onError called once');
        assert.strictEqual(seen[0], err, 'onError error === idle error');
        assert.strictEqual(err.code, 'undefined_word');
        assert.strictEqual(err.phase, 'interpret');
        assert.strictEqual(err.token, 'NOPE');
        assert.strictEqual(vm.lastError, err, 'vm.lastError points to same error');
        assert.strictEqual(vm.running, false, 'vm halted');
      });

      QUnit.test('stack underflow: structured exec error and halt, no further tokens executed', async assert => {
        const { vm, err } = await runCodeExpectErr('DUP 1 2 +');
        assert.strictEqual(err.code, 'stack_underflow');
        assert.strictEqual(err.phase, 'exec');
        assert.ok(typeof err.stackDepth === 'number', 'err.stackDepth is number');
        assert.ok(typeof err.rstackDepth === 'number', 'err.rstackDepth is number');
        assert.ok(typeof err.ip === 'number' || typeof err.ip === 'undefined', 'err.ip present or undefined');
        assert.strictEqual(vm.D.length, 0, 'no subsequent execution after error');
      });

      QUnit.test('rstack underflow: structured exec error', async assert => {
        const { err } = await runCodeExpectErr('R>');
        assert.strictEqual(err.code, 'rstack_underflow');
        assert.strictEqual(err.phase, 'exec');
      });

      QUnit.test('compile-time misuse: ELSE outside compile', async assert => {
        const { err } = await runCodeExpectErr('ELSE');
        assert.strictEqual(err.code, 'else_outside_compile');
        assert.strictEqual(err.phase, 'compile');
      });

      QUnit.test('compile-time: ":" with no name', async assert => {
        const { err } = await runCodeExpectErr(':');
        assert.strictEqual(err.code, 'colon_no_name');
        assert.strictEqual(err.phase, 'compile');
      });

      QUnit.test('errors do not throw synchronously from run()', assert => {
        assert.expect(1);
        const vm = new Fjorth({});
        vm.reset();
        vm.load('NOPE');
        let threw = false;
        try { vm.run(() => {}); } catch (e) { threw = true; }
        assert.strictEqual(threw, false, 'no synchronous throw');
      });
    }

    if (window.QUnit) {
      startErrTests();
    } else {
      window.addEventListener('load', () => { if (window.QUnit) startErrTests(); });
    }
  })();
  </script>
</body>
</html>