host_functions_tests.cpp File Reference

#include <algorithm>
#include <vector>
#include <iterator>
#include <cstdlib>
#include <fstream>
#include <string>
#include <catch2/catch.hpp>
#include <sysio/vm/backend.hpp>
#include "wasm_config.hpp"
#include "utils.hpp"
#include "host_functions_tests_0.wasm.hpp"
#include "host_functions_tests_1.wasm.hpp"

Include dependency graph for host_functions_tests.cpp:

Go to the source code of this file.

Classes
struct	state_t
struct	init_backend< Functions, Host, Impl >
struct	my_host_functions
struct	has_stateful_conversion
struct	stateful_conversion
struct	host_functions_stateful_converter
struct	stateful_cnv
struct	test_exception
struct	host_functions_throw
struct	host_functions_exit< Impl >

Functions
void	c_style_host_function_0 ()
void	c_style_host_function_1 (int s)
void	c_style_host_function_2 (int a, int b)
void	c_style_host_function_3 (int a, float b)
void	c_style_host_function_4 (const state_t &ss)
int	next_ptr_offset ()
template<typename T , typename B >
void	check_put (B &bkend, const std::string &name)
template<typename T , typename B >
void	check_put_ptr (B &bkend, const std::string &name)
template<typename T , typename B >
void	check_put_ref (B &bkend, const std::string &name)
template<typename T , typename B , typename F >
void	check_get (B &bkend, const std::string &name, F getter)
template<typename T , typename B >
void	check_get_ptr (B &bkend, const std::string &name)
template<typename T , typename B >
void	check_get_ref (B &bkend, const std::string &name)
template<class Backend >
void	test_parameters (Backend &&bkend)
	BACKEND_TEST_CASE ("Test host function parameters", "[host_functions_parameters]")
template<class Backend >
void	test_results (Backend &&bkend)
	BACKEND_TEST_CASE ("Test host function results", "[host_functions_results]")
	BACKEND_TEST_CASE ("Test C-style host function system", "[C-style_host_functions_tests]")
	BACKEND_TEST_CASE ("Testing host functions", "[host_functions_test]")
	BACKEND_TEST_CASE ("Testing stateful ", "[host_functions_stateful_converter]")
	BACKEND_TEST_CASE ("Testing throwing host functions", "[host_functions_throw_test]")
	BACKEND_TEST_CASE ("Testing exiting host functions", "[host_functions_exit_test]")

Variables
int	c_style_host_function_state = 0
wasm_code	host_functions_tests_1_code
const std::vector< std::string >	fun_prefixes = { "", "call.", "call_indirect." }
template<typename T >
std::vector< T >	test_values = { 0, 1, std::numeric_limits<T>::min(), std::numeric_limits<T>::max() }
template<>
std::vector< bool >	test_values< bool > = { true, false }
wasm_allocator	wa

Function Documentation

BACKEND_TEST_CASE() [1/7]

BACKEND_TEST_CASE	(	"Test C-style host function system"	,
		""	[C-style_host_functions_tests] )

Definition at line 350 of file host_functions_tests.cpp.

                                                                                          {
   wasm_allocator wa;
   using rhf_t     = sysio::vm::registered_host_functions<standalone_function_t, execution_interface, cnv<standalone_function_t>>;
   using backend_t = sysio::vm::backend<rhf_t, TestType>;
   rhf_t::add<&c_style_host_function_0>("env", "c_style_host_function_0");
   rhf_t::add<&c_style_host_function_1>("env", "c_style_host_function_1");
   rhf_t::add<&c_style_host_function_2>("env", "c_style_host_function_2");
   rhf_t::add<&c_style_host_function_3>("env", "c_style_host_function_3");
   rhf_t::add<&c_style_host_function_4>("env", "c_style_host_function_4");
 
   backend_t bkend(host_functions_test_0_wasm, &wa);
 
   bkend.call("env", "apply", (uint64_t)0, (uint64_t)0, (uint64_t)0);
   CHECK(c_style_host_function_state == 1);
 
   bkend.call("env", "apply", (uint64_t)1, (uint64_t)2, (uint64_t)0);
   CHECK(c_style_host_function_state == 2);
 
   bkend.call("env", "apply", (uint64_t)2, (uint64_t)1, (uint64_t)2);
   CHECK(c_style_host_function_state == 3);
 
   float f = 2.4f;
   bkend.call("env", "apply", (uint64_t)3, (uint64_t)2, (uint64_t)bit_cast<uint32_t>(f));
   CHECK(c_style_host_function_state == 0x40199980);
 
   bkend.call("env", "apply", (uint64_t)4, (uint64_t)5, (uint64_t)bit_cast<uint32_t>(f));
   CHECK(c_style_host_function_state == 5);
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [2/7]

BACKEND_TEST_CASE	(	"Test host function parameters"	,
		""	[host_functions_parameters] )

Definition at line 313 of file host_functions_tests.cpp.

                                                                                    {
   test_parameters(init_backend<static_host_function, nullptr_t, TestType>{nullptr});
   member_host_function mhf;
   test_parameters(init_backend<member_host_function, member_host_function, TestType>{&mhf});
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [3/7]

BACKEND_TEST_CASE	(	"Test host function results"	,
		""	[host_functions_results] )

Definition at line 344 of file host_functions_tests.cpp.

                                                                              {
   test_results(init_backend<static_host_function, nullptr_t, TestType>{nullptr});
   member_host_function mhf;
   test_results(init_backend<member_host_function, member_host_function, TestType>{&mhf});
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [4/7]

BACKEND_TEST_CASE	(	"Testing exiting host functions"	,
		""	[host_functions_exit_test] )

Definition at line 540 of file host_functions_tests.cpp.

                                                                                    {
   using rhf_t = registered_host_functions<host_functions_exit<TestType>>;
   rhf_t::template add<&host_functions_exit<TestType>::test>("host", "test");
   rhf_t::template add<&host_functions_exit<TestType>::test>("host", "test2");
 
   using backend_t = backend<rhf_t, TestType>;
 
   auto code = read_wasm( host_wasm );
   backend_t bkend( code, &wa );
   host_functions_exit<TestType> host{&bkend.get_context()};
 
   CHECK(!bkend.call_with_return(host, "env", "test", UINT32_C(2)));
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [5/7]

BACKEND_TEST_CASE	(	"Testing host functions"	,
		""	[host_functions_test] )

Definition at line 386 of file host_functions_tests.cpp.

                                                                       {
   my_host_functions host;
   using rhf_t = registered_host_functions<standalone_function_t>;
   rhf_t::add<&my_host_functions::test>("host", "test");
   rhf_t::add<&my_host_functions::test2>("host", "test2");
 
   using backend_t = backend<rhf_t, TestType>;
 
   auto code = read_wasm( host_wasm );
   backend_t bkend( code, &wa );
 
   CHECK(bkend.call_with_return("env", "test", UINT32_C(5))->to_i32() == 49);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(0))->to_i32() == 47);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(1))->to_i32() == 210);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(2))->to_i32() == 49);
   CHECK_THROWS_AS(bkend.call("env", "test.indirect", UINT32_C(5), UINT32_C(3)), std::exception);
   CHECK(bkend.call_with_return("env", "test.local-call", UINT32_C(5))->to_i32() == 147);
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [6/7]

BACKEND_TEST_CASE	(	"Testing stateful "	,
		""	[host_functions_stateful_converter] )

Definition at line 430 of file host_functions_tests.cpp.

                                                                               {
   host_functions_stateful_converter host;
   using rhf_t = registered_host_functions<standalone_function_t, execution_interface, stateful_cnv>;
   rhf_t::add<&host_functions_stateful_converter::test>("host", "test");
   rhf_t::add<&host_functions_stateful_converter::test2>("host", "test2");
 
   using backend_t = backend<rhf_t, TestType>;
 
   auto code = read_wasm( host_wasm );
   backend_t bkend( code, &wa );
 
   CHECK(bkend.call_with_return("env", "test", UINT32_C(5))->to_i32() == 49);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(0))->to_i32() == 47);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(1))->to_i32() == 210);
   CHECK(bkend.call_with_return("env", "test.indirect", UINT32_C(5), UINT32_C(2))->to_i32() == 49);
   CHECK_THROWS_AS(bkend.call("env", "test.indirect", UINT32_C(5), UINT32_C(3)), std::exception);
   CHECK(bkend.call_with_return("env", "test.local-call", UINT32_C(5))->to_i32() == 147);
}

Here is the call graph for this function:

BACKEND_TEST_CASE() [7/7]

BACKEND_TEST_CASE	(	"Testing throwing host functions"	,
		""	[host_functions_throw_test] )

Definition at line 520 of file host_functions_tests.cpp.

                                                                                      {
   host_functions_throw host;
   using rhf_t = registered_host_functions<standalone_function_t>;
   rhf_t::add<&host_functions_throw::test>("host", "test");
   rhf_t::add<&host_functions_throw::test>("host", "test2");
 
   using backend_t = backend<rhf_t, TestType>;
 
   auto code = read_wasm( host_wasm );
   backend_t bkend( code, &wa );;
 
   CHECK_THROWS_AS(bkend.call("env", "test", UINT32_C(2)), test_exception);
}

Here is the call graph for this function:

c_style_host_function_0()

void c_style_host_function_0

(

)

Definition at line 57 of file host_functions_tests.cpp.

                               {
   c_style_host_function_state = 1;
}

c_style_host_function_1()

void c_style_host_function_1

(

int

s

)

Definition at line 60 of file host_functions_tests.cpp.

                                    {
   c_style_host_function_state = s;
}

c_style_host_function_2()

void c_style_host_function_2	(	int	a,
		int	b )

Definition at line 63 of file host_functions_tests.cpp.

                                           {
   c_style_host_function_state = a+b;
}

c_style_host_function_3()

void c_style_host_function_3	(	int	a,
		float	b )

Definition at line 66 of file host_functions_tests.cpp.

                                             {
   c_style_host_function_state = a+b;
}

c_style_host_function_4()

void c_style_host_function_4

(

const state_t &

ss

)

Definition at line 69 of file host_functions_tests.cpp.

                                                {
   c_style_host_function_state = ss.i;
}

check_get()

template<typename T , typename B , typename F >

void check_get	(	B &	bkend,
		const std::string &	name,
		F	getter )

Definition at line 252 of file host_functions_tests.cpp.

                                                          {
   for(auto fun : fun_prefixes) {
      fun += "get_" + name;
      for(const T value : test_values<T>) {
         global_test_value<T> = value;
         CHECK(getter(bkend.call_with_return("env", fun)) == value);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_get_ptr()

template<typename T , typename B >

void check_get_ptr	(	B &	bkend,
		const std::string &	name )

Definition at line 263 of file host_functions_tests.cpp.

                                                    {
   for(auto fun : fun_prefixes) {
      fun += "get_" + name;
      int offset = next_ptr_offset();
      global_test_value<T> = const_cast<T>(bkend.get_context().linear_memory() + offset);
      CHECK(bkend.call_with_return("env", fun)->to_ui32() == offset);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_get_ref()

template<typename T , typename B >

void check_get_ref	(	B &	bkend,
		const std::string &	name )

Definition at line 273 of file host_functions_tests.cpp.

                                                    {
   for(auto fun : fun_prefixes) {
      fun += "get_" + name;
      int offset = next_ptr_offset();
      global_test_value<T> = const_cast<T>(*(bkend.get_context().linear_memory() + offset));
      CHECK(bkend.call_with_return("env", fun)->to_ui32() == offset);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_put()

template<typename T , typename B >

void check_put	(	B &	bkend,
		const std::string &	name )

Definition at line 219 of file host_functions_tests.cpp.

                                                {
   for(auto fun : fun_prefixes) {
      fun += "put_" + name;
      for(const T value : test_values<T>) {
         bkend.call("env", fun, value);
         CHECK(global_test_value<T> == value);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_put_ptr()

template<typename T , typename B >

void check_put_ptr	(	B &	bkend,
		const std::string &	name )

Definition at line 230 of file host_functions_tests.cpp.

                                                    {
   for(auto fun : fun_prefixes) {
      fun += "put_" + name;
      int offset = next_ptr_offset();
      const T value = const_cast<T>(bkend.get_context().linear_memory() + offset);
      bkend.call("env", fun, value);
      CHECK(global_test_value<T> == value);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_put_ref()

template<typename T , typename B >

void check_put_ref	(	B &	bkend,
		const std::string &	name )

Definition at line 241 of file host_functions_tests.cpp.

                                                    {
   for(auto fun : fun_prefixes) {
      fun += "put_" + name;
      int offset = next_ptr_offset();
      const auto value = &const_cast<T>(*(bkend.get_context().linear_memory() + offset));
      bkend.call("env", fun, value);
      CHECK(global_test_value<T>.val == value);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

next_ptr_offset()

int next_ptr_offset

(

)

Definition at line 213 of file host_functions_tests.cpp.

                      {
   static int counter = 4;
   return counter++;
}

Here is the caller graph for this function:

test_parameters()

template<class Backend >

void test_parameters

(

Backend &&

bkend

)

Definition at line 283 of file host_functions_tests.cpp.

                                      {
   for(auto fun : fun_prefixes) {
      fun += "put_b";
      bkend.call("env", fun, true);
      CHECK(global_test_value<bool> == true);
      bkend.call("env", fun, false);
      CHECK(global_test_value<bool> == false);
      // Extra tests for bool:
      bkend.call("env", fun, 42);
      CHECK(global_test_value<bool> == true);
      bkend.call("env", fun, 0x10000);
      CHECK(global_test_value<bool> == true);
   }
 
   check_put<int32_t>(bkend, "i32");
   check_put<uint32_t>(bkend, "ui32");
   check_put<int64_t>(bkend, "i64");
   check_put<uint64_t>(bkend, "ui64");
   check_put<float>(bkend, "f32");
   check_put<double>(bkend, "f64");
   check_put_ptr<char*>(bkend, "ptr");
   check_put_ptr<const char*>(bkend, "cptr");
   check_put_ptr<volatile char*>(bkend, "vptr");
   check_put_ptr<const volatile char*>(bkend, "cvptr");
   check_put_ref<char&>(bkend, "ref");
   check_put_ref<const char&>(bkend, "cref");
   check_put_ref<volatile char&>(bkend, "vref");
   check_put_ref<const volatile char&>(bkend, "cvref");
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_results()

template<class Backend >

void test_results

(

Backend &&

bkend

)

Definition at line 320 of file host_functions_tests.cpp.

                                   {
   for(auto fun : {/*"get_b",*/ "call.get_b", "call_indirect.get_b"}) {
      global_test_value<bool> = false;
      CHECK(bkend.call_with_return("env", fun)->to_ui32() == 0u);
      global_test_value<bool> = true;
      CHECK(bkend.call_with_return("env", fun)->to_ui32() == 1u);
   }
 
   check_get<int32_t>(bkend, "i32", [](auto x){ return x->to_i32(); });
   check_get<uint32_t>(bkend, "ui32", [](auto x){ return x->to_ui32(); });
   check_get<int64_t>(bkend, "i64", [](auto x){ return x->to_i64(); });
   check_get<uint64_t>(bkend, "ui64", [](auto x){ return x->to_ui64(); });
   check_get<float>(bkend, "f32", [](auto x){ return x->to_f32(); });
   check_get<double>(bkend, "f64", [](auto x){ return x->to_f64(); });
   check_get_ptr<char*>(bkend, "ptr");
   check_get_ptr<const char*>(bkend, "cptr");
   check_get_ptr<volatile char*>(bkend, "vptr");
   check_get_ptr<const volatile char*>(bkend, "cvptr");
   check_get_ref<char&>(bkend, "ref");
   check_get_ref<const char&>(bkend, "cref");
   check_get_ref<volatile char&>(bkend, "vref");
   check_get_ref<const volatile char&>(bkend, "cvref");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

c_style_host_function_state

int c_style_host_function_state = 0

Definition at line 52 of file host_functions_tests.cpp.

fun_prefixes

const std::vector<std::string> fun_prefixes = { "", "call.", "call_indirect." }

Definition at line 205 of file host_functions_tests.cpp.

{ "", "call.", "call_indirect." };

host_functions_tests_1_code

wasm_code host_functions_tests_1_code

Initial value:

{
   host_functions_tests_1_wasm + 0,
   host_functions_tests_1_wasm + sizeof(host_functions_tests_1_wasm)}

Definition at line 146 of file host_functions_tests.cpp.

                                     {
   host_functions_tests_1_wasm + 0,
   host_functions_tests_1_wasm + sizeof(host_functions_tests_1_wasm)};

test_values

template<typename T >

std::vector<T> test_values = { 0, 1, std::numeric_limits<T>::min(), std::numeric_limits<T>::max() }

Definition at line 208 of file host_functions_tests.cpp.

{ 0, 1, std::numeric_limits<T>::min(), std::numeric_limits<T>::max() };

test_values< bool >

template<>

std::vector<bool> test_values< bool > = { true, false }

Definition at line 208 of file host_functions_tests.cpp.

{ true, false };

wa

wasm_allocator wa

extern

Definition at line 10 of file main.cpp.