InstantiatorTest.v3

// Copyright 2020 Ben L. Titzer. All rights reserved.
// See LICENSE for details of Apache 2.0 license.

def T = UnitTests.registerT("inst:", _, InstantiatorTester.new, _);
def X_ = void(
	T("func1", test_func1),
	T("table1", test_table1),
	T("mem1", test_mem1),
	T("mem2", test_mem2),
	T("global1", test_global1),
	T("global2", test_global2),
	()
);

def newSig = ValueTypes.newSig;
def newHostFunction = HostFunction.new(null, _, null);

class InstantiatorTester(t: Tester) extends ModuleBuilder {
	def assert_fail(bindings: Array<Exportable>) {
		var error = ErrorGen.new("InstantiatorTest.v3");
		var instance = Instantiator.new(extensions, module, bindings, error).run();
		if (instance != null) return t.fail("expected instantiation fail, but passed (non-null instance)");
		if (error.ok()) return t.fail("expected instantiation fail, but passed (no error)");
	}
	def assert_pass(bindings: Array<Exportable>) -> Instance {
		var error = ErrorGen.new("InstantiatorTest.v3");
		var instance = Instantiator.new(extensions, module, bindings, error).run();
		if (error.error()) t.fail1("instantiation failed, got %s", error.error_msg);
		if (instance == null) t.fail("instantiation failed, got null");
		return instance;
	}
	def assert_sig(expected_sig: SigDecl, got_sig: SigDecl) {
		if (got_sig == null) return t.fail1("expected sig %q, got null", expected_sig.render);
		if (!got_sig.isAssignableSig(expected_sig)) {
			t.fail2("expected sig %q, got %q", expected_sig.render, got_sig.render);
		}
	}
	def assert_exportable(expected: Exportable, got: Exportable) {
		if (expected != got) {
			t.fail2("expected exportable %q, got %q", expected.render, got.render);
		}
	}
	def assert_exportables(expected: Array<Exportable>, got: Array<Exportable>) {
		t.assertar("exportable", expected, got, Exportable.render);
	}
}

def newTable(elemtype: ValueType.Ref, initial: u32, max: Max) -> Table {
	return Table.new(elemtype, TableDecl.new(elemtype, SizeConstraint(false, initial, max)));
}

def NONE: Array<Exportable> = [];
def NULL = Array<Exportable>.new(1);
def FUNC: Array<Exportable> = [newHostFunction(SigCache.v_v)];
def TABLE: Array<Exportable> = [newTable(ValueTypes.EXTERNREF, 0, Max.None)];
var MEMORY: Array<Exportable>;
def GLOBAL: Array<Exportable> = [Global.new(ValueType.I32, GlobalDecl.new(ValueType.I32, false, InitExpr.I32(0)))];
def TYPE: Array<Exportable> = [HostType.new()];
def BASIC_TYPES = [
	ValueType.I32, ValueType.I64, ValueType.F32, ValueType.F64, ValueTypes.EXTERNREF, ValueTypes.FUNCREF
];

def newMemory(initial: u64, max: Max, shared: bool) -> MemoryDecl {
	return MemoryDecl.new(SizeConstraint(false, initial, max), shared, BpConstants.log2_WASM_PAGE_SIZE);
}

def memory() -> Array<Exportable> {
	if (MEMORY == null) MEMORY = [Target.newMemory(newMemory(0, Max.Set(0), false))];
	return MEMORY;
}

def test_func1(t: InstantiatorTester) {
	var sig_decl = SigCache.v_v;
	t.module.addDecl(sig_decl);
	t.module.addImport("I", "f", t.newFunc(sig_decl));

	t.assert_fail(NONE);
	t.assert_fail(NULL);
	t.assert_fail(TABLE);
	t.assert_fail(memory());
	t.assert_fail(GLOBAL);
	t.assert_fail(TYPE);
	t.assert_fail([newHostFunction(SigCache.v_i)]);
	t.assert_fail([newHostFunction(SigCache.i_i)]);

	t.assert_pass([newHostFunction(SigCache.v_v)]);
}

def test_table1(t: InstantiatorTester) {
	t.module.addImport("M", "t", TableDecl.new(ValueTypes.EXTERNREF, SizeConstraint(false, 1, Max.Set(3))));

	t.assert_fail(NONE);
	t.assert_fail(NULL);
	t.assert_fail(FUNC);
	t.assert_fail(memory());
	t.assert_fail(GLOBAL);
	t.assert_fail(TYPE);

	t.assert_fail([newTable(ValueTypes.FUNCREF, 1, Max.Set(3))]);
	t.assert_fail([newTable(ValueTypes.ANYREF, 1, Max.Set(3))]);
	t.assert_fail([newTable(ValueTypes.EXTERNREF, 0, Max.Set(3))]);
	t.assert_fail([newTable(ValueTypes.EXTERNREF, 1, Max.Set(4))]);
	t.assert_fail([newTable(ValueTypes.EXTERNREF, 1, Max.None)]);

	t.assert_pass([newTable(ValueTypes.EXTERNREF, 1, Max.Set(3))]);
	t.assert_pass([newTable(ValueTypes.EXTERNREF, 2, Max.Set(3))]);
	t.assert_pass([newTable(ValueTypes.EXTERNREF, 1, Max.Set(2))]);
}

def test_mem1(t: InstantiatorTester) {
	t.module.addImport("N", "m", newMemory(1, Max.Set(3), false));

	t.assert_fail(NONE);
	t.assert_fail(NULL);
	t.assert_fail(FUNC);
	t.assert_fail(TABLE);
	t.assert_fail(GLOBAL);
	t.assert_fail(TYPE);

	t.assert_fail([Target.newMemory(newMemory(0, Max.Set(3), false))]);
	t.assert_fail([Target.newMemory(newMemory(1, Max.Set(4), false))]);
	t.assert_fail([Target.newMemory(newMemory(1, Max.None, false))]);
	t.assert_fail([Target.newMemory(newMemory(1, Max.Set(3), true))]);

	t.assert_pass([Target.newMemory(newMemory(1, Max.Set(3), false))]);
	t.assert_pass([Target.newMemory(newMemory(1, Max.Set(2), false))]);
}

def test_mem2(t: InstantiatorTester) {
	t.module.addImport("N", "m", newMemory(1, Max.Set(3), true));

	t.assert_fail([Target.newMemory(newMemory(1, Max.Set(3), false))]);

	t.assert_pass([Target.newMemory(newMemory(1, Max.Set(3), true))]);
	t.assert_pass([Target.newMemory(newMemory(1, Max.Set(2), true))]);
}

def test_global1(t: InstantiatorTester) {
	t.module.addImport("H", "g", GlobalDecl.new(ValueType.I64, false, InitExpr.I64(5)));

	t.assert_fail(NONE);
	t.assert_fail(NULL);
	t.assert_fail(FUNC);
	t.assert_fail(TABLE);
	t.assert_fail(memory());
	t.assert_fail(TYPE);

	t.assert_fail([Global.new(ValueType.I32, GlobalDecl.new(ValueType.I32, false, InitExpr.I32(55)))]);
	t.assert_fail([Global.new(ValueType.I64, GlobalDecl.new(ValueType.I64, true, InitExpr.I64(55)))]);

	t.assert_pass([Global.new(ValueType.I64, GlobalDecl.new(ValueType.I64, false, InitExpr.I64(55)))]);
}

def test_global2(t: InstantiatorTester) {
	t.module.addImport("H", "g", GlobalDecl.new(ValueType.F64, true, InitExpr.F64(5)));

	t.assert_fail([Global.new(ValueType.I32, GlobalDecl.new(ValueType.I32, false, InitExpr.I32(55)))]);
	t.assert_fail([Global.new(ValueType.F64, GlobalDecl.new(ValueType.F64, false, InitExpr.I64(55)))]);

	t.assert_pass([Global.new(ValueType.F64, GlobalDecl.new(ValueType.F64, true, InitExpr.I64(55)))]);
}


// TODO: more tests for imported function sig compatibility
// TODO: more tests for table elemtype compatibility
// TODO: more tests for global valtype compatibility