max_func_local_bytes_tests.cpp File Reference

#include <sysio/vm/backend.hpp>
#include "utils.hpp"
#include <catch2/catch.hpp>

Include dependency graph for max_func_local_bytes_tests.cpp:

Go to the source code of this file.

Functions
	BACKEND_TEST_CASE ("Test max_func_local_bytes default", "[max_func_local_bytes_test]")
	BACKEND_TEST_CASE ("Test max_func_local_bytes unlimited", "[max_func_local_bytes_test]")
	BACKEND_TEST_CASE ("Test max_func_local_bytes static fail", "[max_func_local_bytes_test]")
	BACKEND_TEST_CASE ("Test max_func_local_bytes static pass", "[max_func_local_bytes_test]")
	BACKEND_TEST_CASE ("Test max_func_local_bytes dynamic fail", "[max_func_local_bytes_test]")
	BACKEND_TEST_CASE ("Test max_func_local_bytes dynamic pass", "[max_func_local_bytes_test]")

Variables
wasm_allocator	wa

Function Documentation

BACKEND_TEST_CASE() [1/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes default"	,
		""	[max_func_local_bytes_test] )

Definition at line 119 of file max_func_local_bytes_tests.cpp.

                                                                                      {
   using backend_t = backend<std::nullptr_t, TestType>;
   backend_t backend_unused(unused_type_wasm, &wa);
   backend_t backend_param(param_16_wasm, &wa);
   backend_t backend_local(local_16_wasm, &wa);
   backend_t backend_stack(stack_16_wasm, &wa);
   backend_t backend_mixed(mixed_16_wasm, &wa);
}

BACKEND_TEST_CASE() [2/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes dynamic fail"	,
		""	[max_func_local_bytes_test] )

Definition at line 229 of file max_func_local_bytes_tests.cpp.

                                                                                           {
   {
   using backend_t = backend<std::nullptr_t, TestType, dynamic_options>;
   CHECK_THROWS_AS(backend_t(param_16_wasm, nullptr, dynamic_options{8, lp}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(param_16_wasm, nullptr, dynamic_options{8, ps}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(local_16_wasm, nullptr, dynamic_options{8, lp}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(local_16_wasm, nullptr, dynamic_options{8, ls}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(stack_16_wasm, nullptr, dynamic_options{8, ls}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(stack_16_wasm, nullptr, dynamic_options{8, ps}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(mixed_16_wasm, nullptr, dynamic_options{8, lp}), wasm_parse_exception);
   }
 
   {
   using backend_t = backend<std::nullptr_t, TestType, dynamic_options_empty_flags>;
   CHECK_THROWS_AS(backend_t(local_16_wasm, nullptr, dynamic_options_empty_flags{8}), wasm_parse_exception);
   CHECK_THROWS_AS(backend_t(stack_16_wasm, nullptr, dynamic_options_empty_flags{8}), wasm_parse_exception);
   }
}

BACKEND_TEST_CASE() [3/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes dynamic pass"	,
		""	[max_func_local_bytes_test] )

Definition at line 248 of file max_func_local_bytes_tests.cpp.

                                                                                           {
   {
   using backend_t = backend<std::nullptr_t, TestType, dynamic_options>;
   backend_t backend_unused(unused_type_wasm, nullptr, dynamic_options{8, lp});
 
   backend_t backend_param1(param_16_wasm, nullptr, dynamic_options{16, lp});
   backend_t backend_param2(param_16_wasm, nullptr, dynamic_options{8, ls});
   backend_t backend_param3(param_16_wasm, nullptr, dynamic_options{16, ps});
   backend_t backend_local1(local_16_wasm, nullptr, dynamic_options{16, lp});
   backend_t backend_local2(local_16_wasm, nullptr, dynamic_options{16, ls});
   backend_t backend_local3(local_16_wasm, nullptr, dynamic_options{8, ps});
   backend_t backend_stack1(stack_16_wasm, nullptr, dynamic_options{8, lp});
   backend_t backend_stack3(stack_16_wasm, nullptr, dynamic_options{16, ps});
 
   backend_t backend_mixed(mixed_16_wasm, nullptr, dynamic_options{16, lp});
   }
   {
   using backend_t = backend<std::nullptr_t, TestType, dynamic_options_empty_flags>;
   backend_t backend_param2(param_16_wasm, nullptr, dynamic_options_empty_flags{8});
   backend_t backend_local2(local_16_wasm, nullptr, dynamic_options_empty_flags{16});
   backend_t backend_stack2(stack_16_wasm, nullptr, dynamic_options_empty_flags{16});
   }
}

BACKEND_TEST_CASE() [4/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes static fail"	,
		""	[max_func_local_bytes_test] )

Definition at line 171 of file max_func_local_bytes_tests.cpp.

                                                                                          {
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<8, lp>>;
      backend_t backend_unused(unused_type_wasm, &wa);
      CHECK_THROWS_AS(backend_t(param_16_wasm, &wa), wasm_parse_exception);
      CHECK_THROWS_AS(backend_t(local_16_wasm, &wa), wasm_parse_exception);
      backend_t backend_stack(stack_16_wasm, &wa);
      CHECK_THROWS_AS(backend_t(mixed_16_wasm, &wa), wasm_parse_exception);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<8, ls>>;
      backend_t backend_param(param_16_wasm, &wa);
      CHECK_THROWS_AS(backend_t(local_16_wasm, &wa), wasm_parse_exception);
      CHECK_THROWS_AS(backend_t(stack_16_wasm, &wa), wasm_parse_exception);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<8, ps>>;
      CHECK_THROWS_AS(backend_t(param_16_wasm, &wa), wasm_parse_exception);
      backend_t backend_local(local_16_wasm, &wa);
      CHECK_THROWS_AS(backend_t(stack_16_wasm, &wa), wasm_parse_exception);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options_empty_flags<8>>;
      backend_t backend_param(param_16_wasm, &wa);
      CHECK_THROWS_AS(backend_t(local_16_wasm, &wa), wasm_parse_exception);
      CHECK_THROWS_AS(backend_t(stack_16_wasm, &wa), wasm_parse_exception);
   }
}

BACKEND_TEST_CASE() [5/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes static pass"	,
		""	[max_func_local_bytes_test] )

Definition at line 200 of file max_func_local_bytes_tests.cpp.

                                                                                          {
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<16, lp>>;
      backend_t backend_unused(unused_type_wasm, &wa);
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
      backend_t backend_mixed(mixed_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<16, ps>>;
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options<16, ls>>;
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, static_options_empty_flags<16>>;
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
   }
}

BACKEND_TEST_CASE() [6/6]

BACKEND_TEST_CASE	(	"Test max_func_local_bytes unlimited"	,
		""	[max_func_local_bytes_test] )

Definition at line 128 of file max_func_local_bytes_tests.cpp.

                                                                                        {
   {
      using backend_t = backend<std::nullptr_t, TestType, empty_options>;
      backend_t backend_unused(unused_type_wasm, &wa);
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
      backend_t backend_mixed(mixed_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, empty_options_static_flags<lp>>;
      backend_t backend_unused(unused_type_wasm, &wa);
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
      backend_t backend_mixed(mixed_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, empty_options_static_flags<ps>>;
      backend_t backend_unused(unused_type_wasm, &wa);
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
      backend_t backend_mixed(mixed_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, empty_options_static_flags<ls>>;
      backend_t backend_unused(unused_type_wasm, &wa);
      backend_t backend_param(param_16_wasm, &wa);
      backend_t backend_local(local_16_wasm, &wa);
      backend_t backend_stack(stack_16_wasm, &wa);
      backend_t backend_mixed(mixed_16_wasm, &wa);
   }
   {
      using backend_t = backend<std::nullptr_t, TestType, empty_options_dynamic_flags>;
      backend_t backend_unused(unused_type_wasm, nullptr, empty_options_dynamic_flags{lps});
      backend_t backend_param(param_16_wasm, nullptr, empty_options_dynamic_flags{lps});
      backend_t backend_local(local_16_wasm, nullptr, empty_options_dynamic_flags{lps});
      backend_t backend_stack(stack_16_wasm, nullptr, empty_options_dynamic_flags{lps});
      backend_t backend_mixed(mixed_16_wasm, nullptr, empty_options_dynamic_flags{lps});
   }
}

Variable Documentation

wa

wasm_allocator wa

extern

Definition at line 10 of file main.cpp.