Add support for returns(nothing) (#19)

Author: tolauwae

src/framework/Reporter.ts

@@ -23,25 +23,26 @@ export function expect(step: Step, actual: Object | void, previous?: Object): Re
     result.completion = Completion.succeeded;
     for (const expectation of step.expected ?? []) {
         for (const [field, entry] of Object.entries(expectation)) {
-            const value = getValue(actual, field);
-            if (value === undefined) {
+            try {
+                const value = getValue(actual, field);
+
+                if (entry.kind === 'primitive') {
+                    result.expectPrimitive(value, entry.value);
+                } else if (entry.kind === 'description') {
+                    result.expectDescription(value, entry.value);
+                } else if (entry.kind === 'comparison') {
+                    result.expectComparison(actual, value, entry.value, entry.message);
+                } else if (entry.kind === 'behaviour') {
+                    if (previous === undefined) {
+                        result.error('Invalid test: no [previous] to compare behaviour to.');
+                        return result;
+                    }
+                    result.expectBehaviour(value, getValue(previous, field), entry.value);
+                }
+            } catch (e) {
                 result.error(`Failure: ${JSON.stringify(actual)} state does not contain '${field}'.`);
                 return result;
             }
-
-            if (entry.kind === 'primitive') {
-                result.expectPrimitive(value, entry.value);
-            } else if (entry.kind === 'description') {
-                result.expectDescription(value, entry.value);
-            } else if (entry.kind === 'comparison') {
-                result.expectComparison(actual, value, entry.value, entry.message);
-            } else if (entry.kind === 'behaviour') {
-                if (previous === undefined) {
-                    result.error('Invalid test: no [previous] to compare behaviour to.');
-                    return result;
-                }
-                result.expectBehaviour(value, getValue(previous, field), entry.value);
-            }
         }
     }
     return result;

src/framework/Testee.ts

@@ -10,6 +10,7 @@ import {OutofPlaceSpecification, PlatformType, TestbedSpecification} from '../te
 import {CompileOutput, CompilerFactory} from '../manage/Compiler';
 import {WABT} from '../util/env';
 import {Completion, expect, Result, ScenarioResult, SuiteResults} from './Reporter';
+import {WASM} from '../sourcemap/Wasm';
 
 export function timeout<T>(label: string, time: number, promise: Promise<T>): Promise<T> {
     if (time === 0) {
@@ -23,6 +24,10 @@ export function timeout<T>(label: string, time: number, promise: Promise<T>): Pr
  * @param field dot string describing the field of the value (or path)
  */
 export function getValue(object: any, field: string): any {
+    if (object?.type == WASM.Type.nothing) {
+        return undefined;
+    }
+
     // convert indexes to properties + remove leading dots
     field = field.replace(/\[(\w+)]/g, '.$1');
     field = field.replace(/^\.?/, '');
@@ -32,7 +37,7 @@ export function getValue(object: any, field: string): any {
             object = object[accessor];
         } else {
             // specified field does not exist
-            return undefined;
+            throw Error(`state does not contain field ${field}`);
         }
     }
     return object;

src/framework/scenario/Invoker.ts

@@ -3,22 +3,24 @@ import {WASM} from '../../sourcemap/Wasm';
 import {Message} from '../../messaging/Message';
 import {Target} from '../Testee';
 import Value = WASM.Value;
+import Type = WASM.Type;
+import nothing = WASM.nothing;
 
 export class Invoker implements Step {
     readonly title: string;
     readonly instruction: Instruction;
     readonly expected?: Expectation[];
     readonly target?: Target;
 
-    constructor(func: string, args: Value[], result: Value, target?: Target) {
-        let prefix = "";
+    constructor(func: string, args: Value[], result: Value | undefined, target?: Target) {
+        let prefix = '';
         this.instruction = invoke(func, args);
-        this.expected = returns(result);
+        this.expected = (result == undefined) ? returns(nothing) : returns(result);
         if (target !== undefined) {
             this.target = target;
             prefix = `${target === Target.supervisor ? '[supervisor] ' : '[proxy]      '}`
         }
-        this.title = `${prefix}CHECK: (${func} ${args.map(val => val.value).join(' ')}) returns ${result.value}`;
+        this.title = `${prefix}CHECK: (${func} ${args.map(val => val.value).join(' ')}) returns ${result?.value ?? 'nothing'}`;
     }
 }
 
@@ -27,5 +29,8 @@ export function invoke(func: string, args: Value[]): Instruction {
 }
 
 export function returns(n: Value): Expectation[] {
+    if (n.type == Type.nothing) {
+        return [{'value': {kind: 'primitive', value: undefined} as Expected<undefined>}]
+    }
     return [{'value': {kind: 'primitive', value: n.value} as Expected<number>}]
 }

src/messaging/Parsers.ts

@@ -4,6 +4,7 @@ import {Ack, Exception} from './Message';
 import {Breakpoint} from '../debug/Breakpoint';
 import {WARDuino} from '../debug/WARDuino';
 import State = WARDuino.State;
+import nothing = WASM.nothing;
 
 export function identityParser(text: string) {
     return stripEnd(text);
@@ -18,6 +19,9 @@ export function invokeParser(text: string): WASM.Value | Exception {
         return {text: text};
     }
     const stack: {value: any, type: any}[] = stateParser(text).stack!;
+    if (stack.length == 0) {
+        return nothing;
+    }
     return stacking(stack)[stack.length - 1];
 }
 

src/sourcemap/Wasm.ts

@@ -4,6 +4,7 @@ export namespace WASM {
         f64,
         i32,
         i64,
+        nothing,
         unknown
     }
 
@@ -19,6 +20,12 @@ export namespace WASM {
         value: number;
     }
 
+    export interface Nothing extends Value {}
+
+    export const nothing: Nothing = {
+        type: Type.nothing, value: 0
+    }
+
     export function i32(n: number): WASM.Value {
         return {value: n, type: Type.i32};
     }

test/address.wast

@@ -3,6 +3,10 @@
   (memory 1)
   (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
 
+  (func (export "func-unwind-by-br")
+    (i32.const 3) (i64.const 1) (br 0)
+  )
+
   (func (export "8u_good1") (param $i i32) (result i32)
     (i32.load8_u offset=0 (local.get $i))                   ;; 97 'a'
   )

test/test.ts

@@ -29,6 +29,9 @@ steps.push(new Invoker('8u_good1', [WASM.i32(0)], WASM.i32(97)));
 // ✔ ((invoke "8u_good3" (i32.const 0)) (i32.const 98))
 steps.push(new Invoker('8u_good3', [WASM.i32(0)], WASM.i32(98)));
 
+// ✔ ((invoke "func-unwind-by-br"))
+steps.push(new Invoker('func-unwind-by-br', [], undefined));
+
 spec.test({
     title: `Test with address_0.wast`,
     program: 'test/address.wast',