aboutsummaryrefslogtreecommitdiffhomepage
path: root/tests/src/SpecTestsuites/Core/MemoryTrapTest.php
diff options
context:
space:
mode:
Diffstat (limited to 'tests/src/SpecTestsuites/Core/MemoryTrapTest.php')
-rw-r--r--tests/src/SpecTestsuites/Core/MemoryTrapTest.php2010
1 files changed, 2010 insertions, 0 deletions
diff --git a/tests/src/SpecTestsuites/Core/MemoryTrapTest.php b/tests/src/SpecTestsuites/Core/MemoryTrapTest.php
new file mode 100644
index 0000000..c4ef0a7
--- /dev/null
+++ b/tests/src/SpecTestsuites/Core/MemoryTrapTest.php
@@ -0,0 +1,2010 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Nsfisis\Waddiwasi\Tests\SpecTestsuites\Core;
+
+use Nsfisis\Waddiwasi\Tests\SpecTestsuites\SpecTestsuiteBase;
+use PHPUnit\Framework\Attributes\Depends;
+
+final class MemoryTrapTest extends SpecTestsuiteBase
+{
+ public function testModule0(): void
+ {
+ $this->runModuleCommand(
+ filename: 'memory_trap.0.wasm',
+ name: null,
+ line: 1,
+ );
+ }
+
+ #[Depends('testModule0')]
+ public function testAssertReturn1(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'i32', 'value' => '42']]],
+ expected: [],
+ line: 21,
+ );
+ }
+
+ #[Depends('testAssertReturn1')]
+ public function testAssertReturn2(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ expected: [['type' => 'i32', 'value' => '42']],
+ line: 22,
+ );
+ }
+
+ #[Depends('testAssertReturn2')]
+ public function testAssertTrap3(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'i32', 'value' => '305419896']]],
+ text: 'out of bounds memory access',
+ line: 23,
+ );
+ }
+
+ #[Depends('testAssertTrap3')]
+ public function testAssertTrap4(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 24,
+ );
+ }
+
+ #[Depends('testAssertTrap4')]
+ public function testAssertTrap5(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i32', 'value' => '13']]],
+ text: 'out of bounds memory access',
+ line: 25,
+ );
+ }
+
+ #[Depends('testAssertTrap5')]
+ public function testAssertTrap6(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 26,
+ );
+ }
+
+ #[Depends('testAssertTrap6')]
+ public function testAssertTrap7(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i32', 'value' => '13']]],
+ text: 'out of bounds memory access',
+ line: 27,
+ );
+ }
+
+ #[Depends('testAssertTrap7')]
+ public function testAssertTrap8(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 28,
+ );
+ }
+
+ #[Depends('testAssertTrap8')]
+ public function testAssertTrap9(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '0'], ['type' => 'i32', 'value' => '13']]],
+ text: 'out of bounds memory access',
+ line: 29,
+ );
+ }
+
+ #[Depends('testAssertTrap9')]
+ public function testAssertTrap10(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 30,
+ );
+ }
+
+ #[Depends('testAssertTrap10')]
+ public function testAssertTrap11(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '2147483648'], ['type' => 'i32', 'value' => '13']]],
+ text: 'out of bounds memory access',
+ line: 31,
+ );
+ }
+
+ #[Depends('testAssertTrap11')]
+ public function testAssertTrap12(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '2147483648']]],
+ text: 'out of bounds memory access',
+ line: 32,
+ );
+ }
+
+ #[Depends('testAssertTrap12')]
+ public function testAssertReturn13(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'memory.grow', 'args' => [['type' => 'i32', 'value' => '65537']]],
+ expected: [['type' => 'i32', 'value' => '4294967295']],
+ line: 33,
+ );
+ }
+
+ #[Depends('testAssertReturn13')]
+ public function testModule14(): void
+ {
+ $this->runModuleCommand(
+ filename: 'memory_trap.1.wasm',
+ name: null,
+ line: 35,
+ );
+ }
+
+ #[Depends('testModule14')]
+ public function testAssertTrap15(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 111,
+ );
+ }
+
+ #[Depends('testAssertTrap15')]
+ public function testAssertTrap16(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 112,
+ );
+ }
+
+ #[Depends('testAssertTrap16')]
+ public function testAssertTrap17(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '65534'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 113,
+ );
+ }
+
+ #[Depends('testAssertTrap17')]
+ public function testAssertTrap18(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 114,
+ );
+ }
+
+ #[Depends('testAssertTrap18')]
+ public function testAssertTrap19(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 115,
+ );
+ }
+
+ #[Depends('testAssertTrap19')]
+ public function testAssertTrap20(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 116,
+ );
+ }
+
+ #[Depends('testAssertTrap20')]
+ public function testAssertTrap21(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 117,
+ );
+ }
+
+ #[Depends('testAssertTrap21')]
+ public function testAssertTrap22(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 118,
+ );
+ }
+
+ #[Depends('testAssertTrap22')]
+ public function testAssertTrap23(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 119,
+ );
+ }
+
+ #[Depends('testAssertTrap23')]
+ public function testAssertTrap24(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 120,
+ );
+ }
+
+ #[Depends('testAssertTrap24')]
+ public function testAssertTrap25(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65534'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 121,
+ );
+ }
+
+ #[Depends('testAssertTrap25')]
+ public function testAssertTrap26(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 122,
+ );
+ }
+
+ #[Depends('testAssertTrap26')]
+ public function testAssertTrap27(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65532'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 123,
+ );
+ }
+
+ #[Depends('testAssertTrap27')]
+ public function testAssertTrap28(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65531'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 124,
+ );
+ }
+
+ #[Depends('testAssertTrap28')]
+ public function testAssertTrap29(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65530'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 125,
+ );
+ }
+
+ #[Depends('testAssertTrap29')]
+ public function testAssertTrap30(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65529'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 126,
+ );
+ }
+
+ #[Depends('testAssertTrap30')]
+ public function testAssertTrap31(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 127,
+ );
+ }
+
+ #[Depends('testAssertTrap31')]
+ public function testAssertTrap32(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 128,
+ );
+ }
+
+ #[Depends('testAssertTrap32')]
+ public function testAssertTrap33(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 129,
+ );
+ }
+
+ #[Depends('testAssertTrap33')]
+ public function testAssertTrap34(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 130,
+ );
+ }
+
+ #[Depends('testAssertTrap34')]
+ public function testAssertTrap35(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967291'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 131,
+ );
+ }
+
+ #[Depends('testAssertTrap35')]
+ public function testAssertTrap36(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967290'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 132,
+ );
+ }
+
+ #[Depends('testAssertTrap36')]
+ public function testAssertTrap37(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967289'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 133,
+ );
+ }
+
+ #[Depends('testAssertTrap37')]
+ public function testAssertTrap38(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '4294967288'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 134,
+ );
+ }
+
+ #[Depends('testAssertTrap38')]
+ public function testAssertTrap39(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 135,
+ );
+ }
+
+ #[Depends('testAssertTrap39')]
+ public function testAssertTrap40(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 136,
+ );
+ }
+
+ #[Depends('testAssertTrap40')]
+ public function testAssertTrap41(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '65534'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 137,
+ );
+ }
+
+ #[Depends('testAssertTrap41')]
+ public function testAssertTrap42(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 138,
+ );
+ }
+
+ #[Depends('testAssertTrap42')]
+ public function testAssertTrap43(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 139,
+ );
+ }
+
+ #[Depends('testAssertTrap43')]
+ public function testAssertTrap44(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 140,
+ );
+ }
+
+ #[Depends('testAssertTrap44')]
+ public function testAssertTrap45(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 141,
+ );
+ }
+
+ #[Depends('testAssertTrap45')]
+ public function testAssertTrap46(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'f32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 142,
+ );
+ }
+
+ #[Depends('testAssertTrap46')]
+ public function testAssertTrap47(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 143,
+ );
+ }
+
+ #[Depends('testAssertTrap47')]
+ public function testAssertTrap48(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 144,
+ );
+ }
+
+ #[Depends('testAssertTrap48')]
+ public function testAssertTrap49(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65534'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 145,
+ );
+ }
+
+ #[Depends('testAssertTrap49')]
+ public function testAssertTrap50(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 146,
+ );
+ }
+
+ #[Depends('testAssertTrap50')]
+ public function testAssertTrap51(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65532'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 147,
+ );
+ }
+
+ #[Depends('testAssertTrap51')]
+ public function testAssertTrap52(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65531'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 148,
+ );
+ }
+
+ #[Depends('testAssertTrap52')]
+ public function testAssertTrap53(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65530'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 149,
+ );
+ }
+
+ #[Depends('testAssertTrap53')]
+ public function testAssertTrap54(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65529'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 150,
+ );
+ }
+
+ #[Depends('testAssertTrap54')]
+ public function testAssertTrap55(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 151,
+ );
+ }
+
+ #[Depends('testAssertTrap55')]
+ public function testAssertTrap56(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 152,
+ );
+ }
+
+ #[Depends('testAssertTrap56')]
+ public function testAssertTrap57(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 153,
+ );
+ }
+
+ #[Depends('testAssertTrap57')]
+ public function testAssertTrap58(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 154,
+ );
+ }
+
+ #[Depends('testAssertTrap58')]
+ public function testAssertTrap59(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967291'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 155,
+ );
+ }
+
+ #[Depends('testAssertTrap59')]
+ public function testAssertTrap60(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967290'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 156,
+ );
+ }
+
+ #[Depends('testAssertTrap60')]
+ public function testAssertTrap61(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967289'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 157,
+ );
+ }
+
+ #[Depends('testAssertTrap61')]
+ public function testAssertTrap62(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '4294967288'], ['type' => 'f64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 158,
+ );
+ }
+
+ #[Depends('testAssertTrap62')]
+ public function testAssertTrap63(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store8', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 159,
+ );
+ }
+
+ #[Depends('testAssertTrap63')]
+ public function testAssertTrap64(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store8', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 160,
+ );
+ }
+
+ #[Depends('testAssertTrap64')]
+ public function testAssertTrap65(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store16', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 161,
+ );
+ }
+
+ #[Depends('testAssertTrap65')]
+ public function testAssertTrap66(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store16', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 162,
+ );
+ }
+
+ #[Depends('testAssertTrap66')]
+ public function testAssertTrap67(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store16', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 163,
+ );
+ }
+
+ #[Depends('testAssertTrap67')]
+ public function testAssertTrap68(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store16', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i32', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 164,
+ );
+ }
+
+ #[Depends('testAssertTrap68')]
+ public function testAssertTrap69(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store8', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 165,
+ );
+ }
+
+ #[Depends('testAssertTrap69')]
+ public function testAssertTrap70(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store8', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 166,
+ );
+ }
+
+ #[Depends('testAssertTrap70')]
+ public function testAssertTrap71(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store16', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 167,
+ );
+ }
+
+ #[Depends('testAssertTrap71')]
+ public function testAssertTrap72(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store16', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 168,
+ );
+ }
+
+ #[Depends('testAssertTrap72')]
+ public function testAssertTrap73(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store16', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 169,
+ );
+ }
+
+ #[Depends('testAssertTrap73')]
+ public function testAssertTrap74(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store16', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 170,
+ );
+ }
+
+ #[Depends('testAssertTrap74')]
+ public function testAssertTrap75(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '65536'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 171,
+ );
+ }
+
+ #[Depends('testAssertTrap75')]
+ public function testAssertTrap76(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '65535'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 172,
+ );
+ }
+
+ #[Depends('testAssertTrap76')]
+ public function testAssertTrap77(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '65534'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 173,
+ );
+ }
+
+ #[Depends('testAssertTrap77')]
+ public function testAssertTrap78(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 174,
+ );
+ }
+
+ #[Depends('testAssertTrap78')]
+ public function testAssertTrap79(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '4294967295'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 175,
+ );
+ }
+
+ #[Depends('testAssertTrap79')]
+ public function testAssertTrap80(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '4294967294'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 176,
+ );
+ }
+
+ #[Depends('testAssertTrap80')]
+ public function testAssertTrap81(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '4294967293'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 177,
+ );
+ }
+
+ #[Depends('testAssertTrap81')]
+ public function testAssertTrap82(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store32', 'args' => [['type' => 'i32', 'value' => '4294967292'], ['type' => 'i64', 'value' => '0']]],
+ text: 'out of bounds memory access',
+ line: 178,
+ );
+ }
+
+ #[Depends('testAssertTrap82')]
+ public function testAssertTrap83(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 179,
+ );
+ }
+
+ #[Depends('testAssertTrap83')]
+ public function testAssertTrap84(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 180,
+ );
+ }
+
+ #[Depends('testAssertTrap84')]
+ public function testAssertTrap85(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 181,
+ );
+ }
+
+ #[Depends('testAssertTrap85')]
+ public function testAssertTrap86(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 182,
+ );
+ }
+
+ #[Depends('testAssertTrap86')]
+ public function testAssertTrap87(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 183,
+ );
+ }
+
+ #[Depends('testAssertTrap87')]
+ public function testAssertTrap88(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 184,
+ );
+ }
+
+ #[Depends('testAssertTrap88')]
+ public function testAssertTrap89(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 185,
+ );
+ }
+
+ #[Depends('testAssertTrap89')]
+ public function testAssertTrap90(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 186,
+ );
+ }
+
+ #[Depends('testAssertTrap90')]
+ public function testAssertTrap91(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 187,
+ );
+ }
+
+ #[Depends('testAssertTrap91')]
+ public function testAssertTrap92(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 188,
+ );
+ }
+
+ #[Depends('testAssertTrap92')]
+ public function testAssertTrap93(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 189,
+ );
+ }
+
+ #[Depends('testAssertTrap93')]
+ public function testAssertTrap94(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 190,
+ );
+ }
+
+ #[Depends('testAssertTrap94')]
+ public function testAssertTrap95(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65532']]],
+ text: 'out of bounds memory access',
+ line: 191,
+ );
+ }
+
+ #[Depends('testAssertTrap95')]
+ public function testAssertTrap96(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65531']]],
+ text: 'out of bounds memory access',
+ line: 192,
+ );
+ }
+
+ #[Depends('testAssertTrap96')]
+ public function testAssertTrap97(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65530']]],
+ text: 'out of bounds memory access',
+ line: 193,
+ );
+ }
+
+ #[Depends('testAssertTrap97')]
+ public function testAssertTrap98(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65529']]],
+ text: 'out of bounds memory access',
+ line: 194,
+ );
+ }
+
+ #[Depends('testAssertTrap98')]
+ public function testAssertTrap99(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 195,
+ );
+ }
+
+ #[Depends('testAssertTrap99')]
+ public function testAssertTrap100(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 196,
+ );
+ }
+
+ #[Depends('testAssertTrap100')]
+ public function testAssertTrap101(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 197,
+ );
+ }
+
+ #[Depends('testAssertTrap101')]
+ public function testAssertTrap102(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 198,
+ );
+ }
+
+ #[Depends('testAssertTrap102')]
+ public function testAssertTrap103(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967291']]],
+ text: 'out of bounds memory access',
+ line: 199,
+ );
+ }
+
+ #[Depends('testAssertTrap103')]
+ public function testAssertTrap104(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967290']]],
+ text: 'out of bounds memory access',
+ line: 200,
+ );
+ }
+
+ #[Depends('testAssertTrap104')]
+ public function testAssertTrap105(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967289']]],
+ text: 'out of bounds memory access',
+ line: 201,
+ );
+ }
+
+ #[Depends('testAssertTrap105')]
+ public function testAssertTrap106(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '4294967288']]],
+ text: 'out of bounds memory access',
+ line: 202,
+ );
+ }
+
+ #[Depends('testAssertTrap106')]
+ public function testAssertTrap107(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 203,
+ );
+ }
+
+ #[Depends('testAssertTrap107')]
+ public function testAssertTrap108(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 204,
+ );
+ }
+
+ #[Depends('testAssertTrap108')]
+ public function testAssertTrap109(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 205,
+ );
+ }
+
+ #[Depends('testAssertTrap109')]
+ public function testAssertTrap110(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 206,
+ );
+ }
+
+ #[Depends('testAssertTrap110')]
+ public function testAssertTrap111(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 207,
+ );
+ }
+
+ #[Depends('testAssertTrap111')]
+ public function testAssertTrap112(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 208,
+ );
+ }
+
+ #[Depends('testAssertTrap112')]
+ public function testAssertTrap113(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 209,
+ );
+ }
+
+ #[Depends('testAssertTrap113')]
+ public function testAssertTrap114(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 210,
+ );
+ }
+
+ #[Depends('testAssertTrap114')]
+ public function testAssertTrap115(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 211,
+ );
+ }
+
+ #[Depends('testAssertTrap115')]
+ public function testAssertTrap116(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 212,
+ );
+ }
+
+ #[Depends('testAssertTrap116')]
+ public function testAssertTrap117(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 213,
+ );
+ }
+
+ #[Depends('testAssertTrap117')]
+ public function testAssertTrap118(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 214,
+ );
+ }
+
+ #[Depends('testAssertTrap118')]
+ public function testAssertTrap119(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65532']]],
+ text: 'out of bounds memory access',
+ line: 215,
+ );
+ }
+
+ #[Depends('testAssertTrap119')]
+ public function testAssertTrap120(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65531']]],
+ text: 'out of bounds memory access',
+ line: 216,
+ );
+ }
+
+ #[Depends('testAssertTrap120')]
+ public function testAssertTrap121(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65530']]],
+ text: 'out of bounds memory access',
+ line: 217,
+ );
+ }
+
+ #[Depends('testAssertTrap121')]
+ public function testAssertTrap122(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65529']]],
+ text: 'out of bounds memory access',
+ line: 218,
+ );
+ }
+
+ #[Depends('testAssertTrap122')]
+ public function testAssertTrap123(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 219,
+ );
+ }
+
+ #[Depends('testAssertTrap123')]
+ public function testAssertTrap124(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 220,
+ );
+ }
+
+ #[Depends('testAssertTrap124')]
+ public function testAssertTrap125(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 221,
+ );
+ }
+
+ #[Depends('testAssertTrap125')]
+ public function testAssertTrap126(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 222,
+ );
+ }
+
+ #[Depends('testAssertTrap126')]
+ public function testAssertTrap127(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967291']]],
+ text: 'out of bounds memory access',
+ line: 223,
+ );
+ }
+
+ #[Depends('testAssertTrap127')]
+ public function testAssertTrap128(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967290']]],
+ text: 'out of bounds memory access',
+ line: 224,
+ );
+ }
+
+ #[Depends('testAssertTrap128')]
+ public function testAssertTrap129(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967289']]],
+ text: 'out of bounds memory access',
+ line: 225,
+ );
+ }
+
+ #[Depends('testAssertTrap129')]
+ public function testAssertTrap130(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '4294967288']]],
+ text: 'out of bounds memory access',
+ line: 226,
+ );
+ }
+
+ #[Depends('testAssertTrap130')]
+ public function testAssertTrap131(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load8_s', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 227,
+ );
+ }
+
+ #[Depends('testAssertTrap131')]
+ public function testAssertTrap132(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load8_s', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 228,
+ );
+ }
+
+ #[Depends('testAssertTrap132')]
+ public function testAssertTrap133(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load8_u', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 229,
+ );
+ }
+
+ #[Depends('testAssertTrap133')]
+ public function testAssertTrap134(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load8_u', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 230,
+ );
+ }
+
+ #[Depends('testAssertTrap134')]
+ public function testAssertTrap135(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_s', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 231,
+ );
+ }
+
+ #[Depends('testAssertTrap135')]
+ public function testAssertTrap136(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_s', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 232,
+ );
+ }
+
+ #[Depends('testAssertTrap136')]
+ public function testAssertTrap137(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_s', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 233,
+ );
+ }
+
+ #[Depends('testAssertTrap137')]
+ public function testAssertTrap138(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_s', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 234,
+ );
+ }
+
+ #[Depends('testAssertTrap138')]
+ public function testAssertTrap139(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_u', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 235,
+ );
+ }
+
+ #[Depends('testAssertTrap139')]
+ public function testAssertTrap140(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_u', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 236,
+ );
+ }
+
+ #[Depends('testAssertTrap140')]
+ public function testAssertTrap141(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_u', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 237,
+ );
+ }
+
+ #[Depends('testAssertTrap141')]
+ public function testAssertTrap142(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load16_u', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 238,
+ );
+ }
+
+ #[Depends('testAssertTrap142')]
+ public function testAssertTrap143(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load8_s', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 239,
+ );
+ }
+
+ #[Depends('testAssertTrap143')]
+ public function testAssertTrap144(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load8_s', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 240,
+ );
+ }
+
+ #[Depends('testAssertTrap144')]
+ public function testAssertTrap145(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load8_u', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 241,
+ );
+ }
+
+ #[Depends('testAssertTrap145')]
+ public function testAssertTrap146(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load8_u', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 242,
+ );
+ }
+
+ #[Depends('testAssertTrap146')]
+ public function testAssertTrap147(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_s', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 243,
+ );
+ }
+
+ #[Depends('testAssertTrap147')]
+ public function testAssertTrap148(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_s', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 244,
+ );
+ }
+
+ #[Depends('testAssertTrap148')]
+ public function testAssertTrap149(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_s', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 245,
+ );
+ }
+
+ #[Depends('testAssertTrap149')]
+ public function testAssertTrap150(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_s', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 246,
+ );
+ }
+
+ #[Depends('testAssertTrap150')]
+ public function testAssertTrap151(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_u', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 247,
+ );
+ }
+
+ #[Depends('testAssertTrap151')]
+ public function testAssertTrap152(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_u', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 248,
+ );
+ }
+
+ #[Depends('testAssertTrap152')]
+ public function testAssertTrap153(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_u', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 249,
+ );
+ }
+
+ #[Depends('testAssertTrap153')]
+ public function testAssertTrap154(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load16_u', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 250,
+ );
+ }
+
+ #[Depends('testAssertTrap154')]
+ public function testAssertTrap155(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 251,
+ );
+ }
+
+ #[Depends('testAssertTrap155')]
+ public function testAssertTrap156(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 252,
+ );
+ }
+
+ #[Depends('testAssertTrap156')]
+ public function testAssertTrap157(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 253,
+ );
+ }
+
+ #[Depends('testAssertTrap157')]
+ public function testAssertTrap158(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 254,
+ );
+ }
+
+ #[Depends('testAssertTrap158')]
+ public function testAssertTrap159(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 255,
+ );
+ }
+
+ #[Depends('testAssertTrap159')]
+ public function testAssertTrap160(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 256,
+ );
+ }
+
+ #[Depends('testAssertTrap160')]
+ public function testAssertTrap161(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 257,
+ );
+ }
+
+ #[Depends('testAssertTrap161')]
+ public function testAssertTrap162(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_s', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 258,
+ );
+ }
+
+ #[Depends('testAssertTrap162')]
+ public function testAssertTrap163(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '65536']]],
+ text: 'out of bounds memory access',
+ line: 259,
+ );
+ }
+
+ #[Depends('testAssertTrap163')]
+ public function testAssertTrap164(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '65535']]],
+ text: 'out of bounds memory access',
+ line: 260,
+ );
+ }
+
+ #[Depends('testAssertTrap164')]
+ public function testAssertTrap165(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '65534']]],
+ text: 'out of bounds memory access',
+ line: 261,
+ );
+ }
+
+ #[Depends('testAssertTrap165')]
+ public function testAssertTrap166(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '65533']]],
+ text: 'out of bounds memory access',
+ line: 262,
+ );
+ }
+
+ #[Depends('testAssertTrap166')]
+ public function testAssertTrap167(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '4294967295']]],
+ text: 'out of bounds memory access',
+ line: 263,
+ );
+ }
+
+ #[Depends('testAssertTrap167')]
+ public function testAssertTrap168(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '4294967294']]],
+ text: 'out of bounds memory access',
+ line: 264,
+ );
+ }
+
+ #[Depends('testAssertTrap168')]
+ public function testAssertTrap169(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '4294967293']]],
+ text: 'out of bounds memory access',
+ line: 265,
+ );
+ }
+
+ #[Depends('testAssertTrap169')]
+ public function testAssertTrap170(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load32_u', 'args' => [['type' => 'i32', 'value' => '4294967292']]],
+ text: 'out of bounds memory access',
+ line: 266,
+ );
+ }
+
+ #[Depends('testAssertTrap170')]
+ public function testAssertReturn171(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65528']]],
+ expected: [['type' => 'i64', 'value' => '7523094288207667809']],
+ line: 269,
+ );
+ }
+
+ #[Depends('testAssertReturn171')]
+ public function testAssertReturn172(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '0']]],
+ expected: [['type' => 'i64', 'value' => '7523094288207667809']],
+ line: 270,
+ );
+ }
+
+ #[Depends('testAssertReturn172')]
+ public function testAssertReturn173(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65528'], ['type' => 'i64', 'value' => '0']]],
+ expected: [],
+ line: 274,
+ );
+ }
+
+ #[Depends('testAssertReturn173')]
+ public function testAssertTrap174(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'i32', 'value' => '305419896']]],
+ text: 'out of bounds memory access',
+ line: 275,
+ );
+ }
+
+ #[Depends('testAssertTrap174')]
+ public function testAssertReturn175(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i32.load', 'args' => [['type' => 'i32', 'value' => '65532']]],
+ expected: [['type' => 'i32', 'value' => '0']],
+ line: 276,
+ );
+ }
+
+ #[Depends('testAssertReturn175')]
+ public function testAssertTrap176(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.store', 'args' => [['type' => 'i32', 'value' => '65529'], ['type' => 'i64', 'value' => '1311768467294899695']]],
+ text: 'out of bounds memory access',
+ line: 277,
+ );
+ }
+
+ #[Depends('testAssertTrap176')]
+ public function testAssertReturn177(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'i64.load', 'args' => [['type' => 'i32', 'value' => '65528']]],
+ expected: [['type' => 'i64', 'value' => '0']],
+ line: 278,
+ );
+ }
+
+ #[Depends('testAssertReturn177')]
+ public function testAssertTrap178(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.store', 'args' => [['type' => 'i32', 'value' => '65533'], ['type' => 'f32', 'value' => '1301390004']]],
+ text: 'out of bounds memory access',
+ line: 279,
+ );
+ }
+
+ #[Depends('testAssertTrap178')]
+ public function testAssertReturn179(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f32.load', 'args' => [['type' => 'i32', 'value' => '65532']]],
+ expected: [['type' => 'f32', 'value' => '0']],
+ line: 280,
+ );
+ }
+
+ #[Depends('testAssertReturn179')]
+ public function testAssertTrap180(): void
+ {
+ $this->runAssertTrapCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.store', 'args' => [['type' => 'i32', 'value' => '65529'], ['type' => 'f64', 'value' => '4878018892390247374']]],
+ text: 'out of bounds memory access',
+ line: 281,
+ );
+ }
+
+ #[Depends('testAssertTrap180')]
+ public function testAssertReturn181(): void
+ {
+ $this->runAssertReturnCommand(
+ module: null,
+ action: ['type' => 'invoke', 'field' => 'f64.load', 'args' => [['type' => 'i32', 'value' => '65528']]],
+ expected: [['type' => 'f64', 'value' => '0']],
+ line: 282,
+ );
+ }
+}
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-11-30 22:32:13 +0000