| |
| // table_copy.wast:6 |
| let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x07\x9f\x80\x80\x80\x00\x05\x03\x65\x66\x30\x00\x00\x03\x65\x66\x31\x00\x01\x03\x65\x66\x32\x00\x02\x03\x65\x66\x33\x00\x03\x03\x65\x66\x34\x00\x04\x0a\xae\x80\x80\x80\x00\x05\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b"); |
| |
| // table_copy.wast:13 |
| register("a", $1) |
| |
| // table_copy.wast:15 |
| let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:45 |
| run(() => call($2, "test", [])); |
| |
| // table_copy.wast:46 |
| assert_trap(() => call($2, "check_t0", [0])); |
| |
| // table_copy.wast:47 |
| assert_trap(() => call($2, "check_t0", [1])); |
| |
| // table_copy.wast:48 |
| assert_return(() => call($2, "check_t0", [2]), 3); |
| |
| // table_copy.wast:49 |
| assert_return(() => call($2, "check_t0", [3]), 1); |
| |
| // table_copy.wast:50 |
| assert_return(() => call($2, "check_t0", [4]), 4); |
| |
| // table_copy.wast:51 |
| assert_return(() => call($2, "check_t0", [5]), 1); |
| |
| // table_copy.wast:52 |
| assert_trap(() => call($2, "check_t0", [6])); |
| |
| // table_copy.wast:53 |
| assert_trap(() => call($2, "check_t0", [7])); |
| |
| // table_copy.wast:54 |
| assert_trap(() => call($2, "check_t0", [8])); |
| |
| // table_copy.wast:55 |
| assert_trap(() => call($2, "check_t0", [9])); |
| |
| // table_copy.wast:56 |
| assert_trap(() => call($2, "check_t0", [10])); |
| |
| // table_copy.wast:57 |
| assert_trap(() => call($2, "check_t0", [11])); |
| |
| // table_copy.wast:58 |
| assert_return(() => call($2, "check_t0", [12]), 7); |
| |
| // table_copy.wast:59 |
| assert_return(() => call($2, "check_t0", [13]), 5); |
| |
| // table_copy.wast:60 |
| assert_return(() => call($2, "check_t0", [14]), 2); |
| |
| // table_copy.wast:61 |
| assert_return(() => call($2, "check_t0", [15]), 3); |
| |
| // table_copy.wast:62 |
| assert_return(() => call($2, "check_t0", [16]), 6); |
| |
| // table_copy.wast:63 |
| assert_trap(() => call($2, "check_t0", [17])); |
| |
| // table_copy.wast:64 |
| assert_trap(() => call($2, "check_t0", [18])); |
| |
| // table_copy.wast:65 |
| assert_trap(() => call($2, "check_t0", [19])); |
| |
| // table_copy.wast:66 |
| assert_trap(() => call($2, "check_t0", [20])); |
| |
| // table_copy.wast:67 |
| assert_trap(() => call($2, "check_t0", [21])); |
| |
| // table_copy.wast:68 |
| assert_trap(() => call($2, "check_t0", [22])); |
| |
| // table_copy.wast:69 |
| assert_trap(() => call($2, "check_t0", [23])); |
| |
| // table_copy.wast:70 |
| assert_trap(() => call($2, "check_t0", [24])); |
| |
| // table_copy.wast:71 |
| assert_trap(() => call($2, "check_t0", [25])); |
| |
| // table_copy.wast:72 |
| assert_trap(() => call($2, "check_t0", [26])); |
| |
| // table_copy.wast:73 |
| assert_trap(() => call($2, "check_t0", [27])); |
| |
| // table_copy.wast:74 |
| assert_trap(() => call($2, "check_t0", [28])); |
| |
| // table_copy.wast:75 |
| assert_trap(() => call($2, "check_t0", [29])); |
| |
| // table_copy.wast:76 |
| assert_trap(() => call($2, "check_t1", [0])); |
| |
| // table_copy.wast:77 |
| assert_trap(() => call($2, "check_t1", [1])); |
| |
| // table_copy.wast:78 |
| assert_trap(() => call($2, "check_t1", [2])); |
| |
| // table_copy.wast:79 |
| assert_return(() => call($2, "check_t1", [3]), 1); |
| |
| // table_copy.wast:80 |
| assert_return(() => call($2, "check_t1", [4]), 3); |
| |
| // table_copy.wast:81 |
| assert_return(() => call($2, "check_t1", [5]), 1); |
| |
| // table_copy.wast:82 |
| assert_return(() => call($2, "check_t1", [6]), 4); |
| |
| // table_copy.wast:83 |
| assert_trap(() => call($2, "check_t1", [7])); |
| |
| // table_copy.wast:84 |
| assert_trap(() => call($2, "check_t1", [8])); |
| |
| // table_copy.wast:85 |
| assert_trap(() => call($2, "check_t1", [9])); |
| |
| // table_copy.wast:86 |
| assert_trap(() => call($2, "check_t1", [10])); |
| |
| // table_copy.wast:87 |
| assert_return(() => call($2, "check_t1", [11]), 6); |
| |
| // table_copy.wast:88 |
| assert_return(() => call($2, "check_t1", [12]), 3); |
| |
| // table_copy.wast:89 |
| assert_return(() => call($2, "check_t1", [13]), 2); |
| |
| // table_copy.wast:90 |
| assert_return(() => call($2, "check_t1", [14]), 5); |
| |
| // table_copy.wast:91 |
| assert_return(() => call($2, "check_t1", [15]), 7); |
| |
| // table_copy.wast:92 |
| assert_trap(() => call($2, "check_t1", [16])); |
| |
| // table_copy.wast:93 |
| assert_trap(() => call($2, "check_t1", [17])); |
| |
| // table_copy.wast:94 |
| assert_trap(() => call($2, "check_t1", [18])); |
| |
| // table_copy.wast:95 |
| assert_trap(() => call($2, "check_t1", [19])); |
| |
| // table_copy.wast:96 |
| assert_trap(() => call($2, "check_t1", [20])); |
| |
| // table_copy.wast:97 |
| assert_trap(() => call($2, "check_t1", [21])); |
| |
| // table_copy.wast:98 |
| assert_trap(() => call($2, "check_t1", [22])); |
| |
| // table_copy.wast:99 |
| assert_trap(() => call($2, "check_t1", [23])); |
| |
| // table_copy.wast:100 |
| assert_trap(() => call($2, "check_t1", [24])); |
| |
| // table_copy.wast:101 |
| assert_trap(() => call($2, "check_t1", [25])); |
| |
| // table_copy.wast:102 |
| assert_trap(() => call($2, "check_t1", [26])); |
| |
| // table_copy.wast:103 |
| assert_trap(() => call($2, "check_t1", [27])); |
| |
| // table_copy.wast:104 |
| assert_trap(() => call($2, "check_t1", [28])); |
| |
| // table_copy.wast:105 |
| assert_trap(() => call($2, "check_t1", [29])); |
| |
| // table_copy.wast:107 |
| let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:137 |
| run(() => call($3, "test", [])); |
| |
| // table_copy.wast:138 |
| assert_trap(() => call($3, "check_t0", [0])); |
| |
| // table_copy.wast:139 |
| assert_trap(() => call($3, "check_t0", [1])); |
| |
| // table_copy.wast:140 |
| assert_return(() => call($3, "check_t0", [2]), 3); |
| |
| // table_copy.wast:141 |
| assert_return(() => call($3, "check_t0", [3]), 1); |
| |
| // table_copy.wast:142 |
| assert_return(() => call($3, "check_t0", [4]), 4); |
| |
| // table_copy.wast:143 |
| assert_return(() => call($3, "check_t0", [5]), 1); |
| |
| // table_copy.wast:144 |
| assert_trap(() => call($3, "check_t0", [6])); |
| |
| // table_copy.wast:145 |
| assert_trap(() => call($3, "check_t0", [7])); |
| |
| // table_copy.wast:146 |
| assert_trap(() => call($3, "check_t0", [8])); |
| |
| // table_copy.wast:147 |
| assert_trap(() => call($3, "check_t0", [9])); |
| |
| // table_copy.wast:148 |
| assert_trap(() => call($3, "check_t0", [10])); |
| |
| // table_copy.wast:149 |
| assert_trap(() => call($3, "check_t0", [11])); |
| |
| // table_copy.wast:150 |
| assert_return(() => call($3, "check_t0", [12]), 7); |
| |
| // table_copy.wast:151 |
| assert_return(() => call($3, "check_t0", [13]), 3); |
| |
| // table_copy.wast:152 |
| assert_return(() => call($3, "check_t0", [14]), 1); |
| |
| // table_copy.wast:153 |
| assert_return(() => call($3, "check_t0", [15]), 4); |
| |
| // table_copy.wast:154 |
| assert_return(() => call($3, "check_t0", [16]), 6); |
| |
| // table_copy.wast:155 |
| assert_trap(() => call($3, "check_t0", [17])); |
| |
| // table_copy.wast:156 |
| assert_trap(() => call($3, "check_t0", [18])); |
| |
| // table_copy.wast:157 |
| assert_trap(() => call($3, "check_t0", [19])); |
| |
| // table_copy.wast:158 |
| assert_trap(() => call($3, "check_t0", [20])); |
| |
| // table_copy.wast:159 |
| assert_trap(() => call($3, "check_t0", [21])); |
| |
| // table_copy.wast:160 |
| assert_trap(() => call($3, "check_t0", [22])); |
| |
| // table_copy.wast:161 |
| assert_trap(() => call($3, "check_t0", [23])); |
| |
| // table_copy.wast:162 |
| assert_trap(() => call($3, "check_t0", [24])); |
| |
| // table_copy.wast:163 |
| assert_trap(() => call($3, "check_t0", [25])); |
| |
| // table_copy.wast:164 |
| assert_trap(() => call($3, "check_t0", [26])); |
| |
| // table_copy.wast:165 |
| assert_trap(() => call($3, "check_t0", [27])); |
| |
| // table_copy.wast:166 |
| assert_trap(() => call($3, "check_t0", [28])); |
| |
| // table_copy.wast:167 |
| assert_trap(() => call($3, "check_t0", [29])); |
| |
| // table_copy.wast:168 |
| assert_trap(() => call($3, "check_t1", [0])); |
| |
| // table_copy.wast:169 |
| assert_trap(() => call($3, "check_t1", [1])); |
| |
| // table_copy.wast:170 |
| assert_trap(() => call($3, "check_t1", [2])); |
| |
| // table_copy.wast:171 |
| assert_return(() => call($3, "check_t1", [3]), 1); |
| |
| // table_copy.wast:172 |
| assert_return(() => call($3, "check_t1", [4]), 3); |
| |
| // table_copy.wast:173 |
| assert_return(() => call($3, "check_t1", [5]), 1); |
| |
| // table_copy.wast:174 |
| assert_return(() => call($3, "check_t1", [6]), 4); |
| |
| // table_copy.wast:175 |
| assert_trap(() => call($3, "check_t1", [7])); |
| |
| // table_copy.wast:176 |
| assert_trap(() => call($3, "check_t1", [8])); |
| |
| // table_copy.wast:177 |
| assert_trap(() => call($3, "check_t1", [9])); |
| |
| // table_copy.wast:178 |
| assert_trap(() => call($3, "check_t1", [10])); |
| |
| // table_copy.wast:179 |
| assert_return(() => call($3, "check_t1", [11]), 6); |
| |
| // table_copy.wast:180 |
| assert_return(() => call($3, "check_t1", [12]), 3); |
| |
| // table_copy.wast:181 |
| assert_return(() => call($3, "check_t1", [13]), 2); |
| |
| // table_copy.wast:182 |
| assert_return(() => call($3, "check_t1", [14]), 5); |
| |
| // table_copy.wast:183 |
| assert_return(() => call($3, "check_t1", [15]), 7); |
| |
| // table_copy.wast:184 |
| assert_trap(() => call($3, "check_t1", [16])); |
| |
| // table_copy.wast:185 |
| assert_trap(() => call($3, "check_t1", [17])); |
| |
| // table_copy.wast:186 |
| assert_trap(() => call($3, "check_t1", [18])); |
| |
| // table_copy.wast:187 |
| assert_trap(() => call($3, "check_t1", [19])); |
| |
| // table_copy.wast:188 |
| assert_trap(() => call($3, "check_t1", [20])); |
| |
| // table_copy.wast:189 |
| assert_trap(() => call($3, "check_t1", [21])); |
| |
| // table_copy.wast:190 |
| assert_trap(() => call($3, "check_t1", [22])); |
| |
| // table_copy.wast:191 |
| assert_trap(() => call($3, "check_t1", [23])); |
| |
| // table_copy.wast:192 |
| assert_trap(() => call($3, "check_t1", [24])); |
| |
| // table_copy.wast:193 |
| assert_trap(() => call($3, "check_t1", [25])); |
| |
| // table_copy.wast:194 |
| assert_trap(() => call($3, "check_t1", [26])); |
| |
| // table_copy.wast:195 |
| assert_trap(() => call($3, "check_t1", [27])); |
| |
| // table_copy.wast:196 |
| assert_trap(() => call($3, "check_t1", [28])); |
| |
| // table_copy.wast:197 |
| assert_trap(() => call($3, "check_t1", [29])); |
| |
| // table_copy.wast:199 |
| let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:229 |
| run(() => call($4, "test", [])); |
| |
| // table_copy.wast:230 |
| assert_trap(() => call($4, "check_t0", [0])); |
| |
| // table_copy.wast:231 |
| assert_trap(() => call($4, "check_t0", [1])); |
| |
| // table_copy.wast:232 |
| assert_return(() => call($4, "check_t0", [2]), 3); |
| |
| // table_copy.wast:233 |
| assert_return(() => call($4, "check_t0", [3]), 1); |
| |
| // table_copy.wast:234 |
| assert_return(() => call($4, "check_t0", [4]), 4); |
| |
| // table_copy.wast:235 |
| assert_return(() => call($4, "check_t0", [5]), 1); |
| |
| // table_copy.wast:236 |
| assert_trap(() => call($4, "check_t0", [6])); |
| |
| // table_copy.wast:237 |
| assert_trap(() => call($4, "check_t0", [7])); |
| |
| // table_copy.wast:238 |
| assert_trap(() => call($4, "check_t0", [8])); |
| |
| // table_copy.wast:239 |
| assert_trap(() => call($4, "check_t0", [9])); |
| |
| // table_copy.wast:240 |
| assert_trap(() => call($4, "check_t0", [10])); |
| |
| // table_copy.wast:241 |
| assert_trap(() => call($4, "check_t0", [11])); |
| |
| // table_copy.wast:242 |
| assert_return(() => call($4, "check_t0", [12]), 7); |
| |
| // table_copy.wast:243 |
| assert_return(() => call($4, "check_t0", [13]), 5); |
| |
| // table_copy.wast:244 |
| assert_return(() => call($4, "check_t0", [14]), 2); |
| |
| // table_copy.wast:245 |
| assert_return(() => call($4, "check_t0", [15]), 3); |
| |
| // table_copy.wast:246 |
| assert_return(() => call($4, "check_t0", [16]), 6); |
| |
| // table_copy.wast:247 |
| assert_trap(() => call($4, "check_t0", [17])); |
| |
| // table_copy.wast:248 |
| assert_trap(() => call($4, "check_t0", [18])); |
| |
| // table_copy.wast:249 |
| assert_trap(() => call($4, "check_t0", [19])); |
| |
| // table_copy.wast:250 |
| assert_trap(() => call($4, "check_t0", [20])); |
| |
| // table_copy.wast:251 |
| assert_trap(() => call($4, "check_t0", [21])); |
| |
| // table_copy.wast:252 |
| assert_trap(() => call($4, "check_t0", [22])); |
| |
| // table_copy.wast:253 |
| assert_trap(() => call($4, "check_t0", [23])); |
| |
| // table_copy.wast:254 |
| assert_trap(() => call($4, "check_t0", [24])); |
| |
| // table_copy.wast:255 |
| assert_return(() => call($4, "check_t0", [25]), 3); |
| |
| // table_copy.wast:256 |
| assert_return(() => call($4, "check_t0", [26]), 6); |
| |
| // table_copy.wast:257 |
| assert_trap(() => call($4, "check_t0", [27])); |
| |
| // table_copy.wast:258 |
| assert_trap(() => call($4, "check_t0", [28])); |
| |
| // table_copy.wast:259 |
| assert_trap(() => call($4, "check_t0", [29])); |
| |
| // table_copy.wast:260 |
| assert_trap(() => call($4, "check_t1", [0])); |
| |
| // table_copy.wast:261 |
| assert_trap(() => call($4, "check_t1", [1])); |
| |
| // table_copy.wast:262 |
| assert_trap(() => call($4, "check_t1", [2])); |
| |
| // table_copy.wast:263 |
| assert_return(() => call($4, "check_t1", [3]), 1); |
| |
| // table_copy.wast:264 |
| assert_return(() => call($4, "check_t1", [4]), 3); |
| |
| // table_copy.wast:265 |
| assert_return(() => call($4, "check_t1", [5]), 1); |
| |
| // table_copy.wast:266 |
| assert_return(() => call($4, "check_t1", [6]), 4); |
| |
| // table_copy.wast:267 |
| assert_trap(() => call($4, "check_t1", [7])); |
| |
| // table_copy.wast:268 |
| assert_trap(() => call($4, "check_t1", [8])); |
| |
| // table_copy.wast:269 |
| assert_trap(() => call($4, "check_t1", [9])); |
| |
| // table_copy.wast:270 |
| assert_trap(() => call($4, "check_t1", [10])); |
| |
| // table_copy.wast:271 |
| assert_return(() => call($4, "check_t1", [11]), 6); |
| |
| // table_copy.wast:272 |
| assert_return(() => call($4, "check_t1", [12]), 3); |
| |
| // table_copy.wast:273 |
| assert_return(() => call($4, "check_t1", [13]), 2); |
| |
| // table_copy.wast:274 |
| assert_return(() => call($4, "check_t1", [14]), 5); |
| |
| // table_copy.wast:275 |
| assert_return(() => call($4, "check_t1", [15]), 7); |
| |
| // table_copy.wast:276 |
| assert_trap(() => call($4, "check_t1", [16])); |
| |
| // table_copy.wast:277 |
| assert_trap(() => call($4, "check_t1", [17])); |
| |
| // table_copy.wast:278 |
| assert_trap(() => call($4, "check_t1", [18])); |
| |
| // table_copy.wast:279 |
| assert_trap(() => call($4, "check_t1", [19])); |
| |
| // table_copy.wast:280 |
| assert_trap(() => call($4, "check_t1", [20])); |
| |
| // table_copy.wast:281 |
| assert_trap(() => call($4, "check_t1", [21])); |
| |
| // table_copy.wast:282 |
| assert_trap(() => call($4, "check_t1", [22])); |
| |
| // table_copy.wast:283 |
| assert_trap(() => call($4, "check_t1", [23])); |
| |
| // table_copy.wast:284 |
| assert_trap(() => call($4, "check_t1", [24])); |
| |
| // table_copy.wast:285 |
| assert_trap(() => call($4, "check_t1", [25])); |
| |
| // table_copy.wast:286 |
| assert_trap(() => call($4, "check_t1", [26])); |
| |
| // table_copy.wast:287 |
| assert_trap(() => call($4, "check_t1", [27])); |
| |
| // table_copy.wast:288 |
| assert_trap(() => call($4, "check_t1", [28])); |
| |
| // table_copy.wast:289 |
| assert_trap(() => call($4, "check_t1", [29])); |
| |
| // table_copy.wast:291 |
| let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:321 |
| run(() => call($5, "test", [])); |
| |
| // table_copy.wast:322 |
| assert_trap(() => call($5, "check_t0", [0])); |
| |
| // table_copy.wast:323 |
| assert_trap(() => call($5, "check_t0", [1])); |
| |
| // table_copy.wast:324 |
| assert_return(() => call($5, "check_t0", [2]), 3); |
| |
| // table_copy.wast:325 |
| assert_return(() => call($5, "check_t0", [3]), 1); |
| |
| // table_copy.wast:326 |
| assert_return(() => call($5, "check_t0", [4]), 4); |
| |
| // table_copy.wast:327 |
| assert_return(() => call($5, "check_t0", [5]), 1); |
| |
| // table_copy.wast:328 |
| assert_trap(() => call($5, "check_t0", [6])); |
| |
| // table_copy.wast:329 |
| assert_trap(() => call($5, "check_t0", [7])); |
| |
| // table_copy.wast:330 |
| assert_trap(() => call($5, "check_t0", [8])); |
| |
| // table_copy.wast:331 |
| assert_trap(() => call($5, "check_t0", [9])); |
| |
| // table_copy.wast:332 |
| assert_trap(() => call($5, "check_t0", [10])); |
| |
| // table_copy.wast:333 |
| assert_trap(() => call($5, "check_t0", [11])); |
| |
| // table_copy.wast:334 |
| assert_return(() => call($5, "check_t0", [12]), 7); |
| |
| // table_copy.wast:335 |
| assert_trap(() => call($5, "check_t0", [13])); |
| |
| // table_copy.wast:336 |
| assert_trap(() => call($5, "check_t0", [14])); |
| |
| // table_copy.wast:337 |
| assert_trap(() => call($5, "check_t0", [15])); |
| |
| // table_copy.wast:338 |
| assert_return(() => call($5, "check_t0", [16]), 6); |
| |
| // table_copy.wast:339 |
| assert_trap(() => call($5, "check_t0", [17])); |
| |
| // table_copy.wast:340 |
| assert_trap(() => call($5, "check_t0", [18])); |
| |
| // table_copy.wast:341 |
| assert_trap(() => call($5, "check_t0", [19])); |
| |
| // table_copy.wast:342 |
| assert_trap(() => call($5, "check_t0", [20])); |
| |
| // table_copy.wast:343 |
| assert_trap(() => call($5, "check_t0", [21])); |
| |
| // table_copy.wast:344 |
| assert_trap(() => call($5, "check_t0", [22])); |
| |
| // table_copy.wast:345 |
| assert_trap(() => call($5, "check_t0", [23])); |
| |
| // table_copy.wast:346 |
| assert_trap(() => call($5, "check_t0", [24])); |
| |
| // table_copy.wast:347 |
| assert_trap(() => call($5, "check_t0", [25])); |
| |
| // table_copy.wast:348 |
| assert_trap(() => call($5, "check_t0", [26])); |
| |
| // table_copy.wast:349 |
| assert_trap(() => call($5, "check_t0", [27])); |
| |
| // table_copy.wast:350 |
| assert_trap(() => call($5, "check_t0", [28])); |
| |
| // table_copy.wast:351 |
| assert_trap(() => call($5, "check_t0", [29])); |
| |
| // table_copy.wast:352 |
| assert_trap(() => call($5, "check_t1", [0])); |
| |
| // table_copy.wast:353 |
| assert_trap(() => call($5, "check_t1", [1])); |
| |
| // table_copy.wast:354 |
| assert_trap(() => call($5, "check_t1", [2])); |
| |
| // table_copy.wast:355 |
| assert_return(() => call($5, "check_t1", [3]), 1); |
| |
| // table_copy.wast:356 |
| assert_return(() => call($5, "check_t1", [4]), 3); |
| |
| // table_copy.wast:357 |
| assert_return(() => call($5, "check_t1", [5]), 1); |
| |
| // table_copy.wast:358 |
| assert_return(() => call($5, "check_t1", [6]), 4); |
| |
| // table_copy.wast:359 |
| assert_trap(() => call($5, "check_t1", [7])); |
| |
| // table_copy.wast:360 |
| assert_trap(() => call($5, "check_t1", [8])); |
| |
| // table_copy.wast:361 |
| assert_trap(() => call($5, "check_t1", [9])); |
| |
| // table_copy.wast:362 |
| assert_trap(() => call($5, "check_t1", [10])); |
| |
| // table_copy.wast:363 |
| assert_return(() => call($5, "check_t1", [11]), 6); |
| |
| // table_copy.wast:364 |
| assert_return(() => call($5, "check_t1", [12]), 3); |
| |
| // table_copy.wast:365 |
| assert_return(() => call($5, "check_t1", [13]), 2); |
| |
| // table_copy.wast:366 |
| assert_return(() => call($5, "check_t1", [14]), 5); |
| |
| // table_copy.wast:367 |
| assert_return(() => call($5, "check_t1", [15]), 7); |
| |
| // table_copy.wast:368 |
| assert_trap(() => call($5, "check_t1", [16])); |
| |
| // table_copy.wast:369 |
| assert_trap(() => call($5, "check_t1", [17])); |
| |
| // table_copy.wast:370 |
| assert_trap(() => call($5, "check_t1", [18])); |
| |
| // table_copy.wast:371 |
| assert_trap(() => call($5, "check_t1", [19])); |
| |
| // table_copy.wast:372 |
| assert_trap(() => call($5, "check_t1", [20])); |
| |
| // table_copy.wast:373 |
| assert_trap(() => call($5, "check_t1", [21])); |
| |
| // table_copy.wast:374 |
| assert_trap(() => call($5, "check_t1", [22])); |
| |
| // table_copy.wast:375 |
| assert_trap(() => call($5, "check_t1", [23])); |
| |
| // table_copy.wast:376 |
| assert_trap(() => call($5, "check_t1", [24])); |
| |
| // table_copy.wast:377 |
| assert_trap(() => call($5, "check_t1", [25])); |
| |
| // table_copy.wast:378 |
| assert_trap(() => call($5, "check_t1", [26])); |
| |
| // table_copy.wast:379 |
| assert_trap(() => call($5, "check_t1", [27])); |
| |
| // table_copy.wast:380 |
| assert_trap(() => call($5, "check_t1", [28])); |
| |
| // table_copy.wast:381 |
| assert_trap(() => call($5, "check_t1", [29])); |
| |
| // table_copy.wast:383 |
| let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:413 |
| run(() => call($6, "test", [])); |
| |
| // table_copy.wast:414 |
| assert_trap(() => call($6, "check_t0", [0])); |
| |
| // table_copy.wast:415 |
| assert_trap(() => call($6, "check_t0", [1])); |
| |
| // table_copy.wast:416 |
| assert_return(() => call($6, "check_t0", [2]), 3); |
| |
| // table_copy.wast:417 |
| assert_return(() => call($6, "check_t0", [3]), 1); |
| |
| // table_copy.wast:418 |
| assert_return(() => call($6, "check_t0", [4]), 4); |
| |
| // table_copy.wast:419 |
| assert_return(() => call($6, "check_t0", [5]), 1); |
| |
| // table_copy.wast:420 |
| assert_trap(() => call($6, "check_t0", [6])); |
| |
| // table_copy.wast:421 |
| assert_trap(() => call($6, "check_t0", [7])); |
| |
| // table_copy.wast:422 |
| assert_trap(() => call($6, "check_t0", [8])); |
| |
| // table_copy.wast:423 |
| assert_trap(() => call($6, "check_t0", [9])); |
| |
| // table_copy.wast:424 |
| assert_trap(() => call($6, "check_t0", [10])); |
| |
| // table_copy.wast:425 |
| assert_trap(() => call($6, "check_t0", [11])); |
| |
| // table_copy.wast:426 |
| assert_return(() => call($6, "check_t0", [12]), 7); |
| |
| // table_copy.wast:427 |
| assert_return(() => call($6, "check_t0", [13]), 5); |
| |
| // table_copy.wast:428 |
| assert_return(() => call($6, "check_t0", [14]), 2); |
| |
| // table_copy.wast:429 |
| assert_return(() => call($6, "check_t0", [15]), 3); |
| |
| // table_copy.wast:430 |
| assert_return(() => call($6, "check_t0", [16]), 6); |
| |
| // table_copy.wast:431 |
| assert_trap(() => call($6, "check_t0", [17])); |
| |
| // table_copy.wast:432 |
| assert_trap(() => call($6, "check_t0", [18])); |
| |
| // table_copy.wast:433 |
| assert_trap(() => call($6, "check_t0", [19])); |
| |
| // table_copy.wast:434 |
| assert_trap(() => call($6, "check_t0", [20])); |
| |
| // table_copy.wast:435 |
| assert_trap(() => call($6, "check_t0", [21])); |
| |
| // table_copy.wast:436 |
| assert_trap(() => call($6, "check_t0", [22])); |
| |
| // table_copy.wast:437 |
| assert_trap(() => call($6, "check_t0", [23])); |
| |
| // table_copy.wast:438 |
| assert_trap(() => call($6, "check_t0", [24])); |
| |
| // table_copy.wast:439 |
| assert_trap(() => call($6, "check_t0", [25])); |
| |
| // table_copy.wast:440 |
| assert_trap(() => call($6, "check_t0", [26])); |
| |
| // table_copy.wast:441 |
| assert_trap(() => call($6, "check_t0", [27])); |
| |
| // table_copy.wast:442 |
| assert_trap(() => call($6, "check_t0", [28])); |
| |
| // table_copy.wast:443 |
| assert_trap(() => call($6, "check_t0", [29])); |
| |
| // table_copy.wast:444 |
| assert_trap(() => call($6, "check_t1", [0])); |
| |
| // table_copy.wast:445 |
| assert_trap(() => call($6, "check_t1", [1])); |
| |
| // table_copy.wast:446 |
| assert_trap(() => call($6, "check_t1", [2])); |
| |
| // table_copy.wast:447 |
| assert_return(() => call($6, "check_t1", [3]), 1); |
| |
| // table_copy.wast:448 |
| assert_return(() => call($6, "check_t1", [4]), 3); |
| |
| // table_copy.wast:449 |
| assert_return(() => call($6, "check_t1", [5]), 1); |
| |
| // table_copy.wast:450 |
| assert_return(() => call($6, "check_t1", [6]), 4); |
| |
| // table_copy.wast:451 |
| assert_trap(() => call($6, "check_t1", [7])); |
| |
| // table_copy.wast:452 |
| assert_trap(() => call($6, "check_t1", [8])); |
| |
| // table_copy.wast:453 |
| assert_trap(() => call($6, "check_t1", [9])); |
| |
| // table_copy.wast:454 |
| assert_trap(() => call($6, "check_t1", [10])); |
| |
| // table_copy.wast:455 |
| assert_return(() => call($6, "check_t1", [11]), 6); |
| |
| // table_copy.wast:456 |
| assert_return(() => call($6, "check_t1", [12]), 3); |
| |
| // table_copy.wast:457 |
| assert_return(() => call($6, "check_t1", [13]), 2); |
| |
| // table_copy.wast:458 |
| assert_return(() => call($6, "check_t1", [14]), 5); |
| |
| // table_copy.wast:459 |
| assert_return(() => call($6, "check_t1", [15]), 7); |
| |
| // table_copy.wast:460 |
| assert_trap(() => call($6, "check_t1", [16])); |
| |
| // table_copy.wast:461 |
| assert_trap(() => call($6, "check_t1", [17])); |
| |
| // table_copy.wast:462 |
| assert_trap(() => call($6, "check_t1", [18])); |
| |
| // table_copy.wast:463 |
| assert_trap(() => call($6, "check_t1", [19])); |
| |
| // table_copy.wast:464 |
| assert_trap(() => call($6, "check_t1", [20])); |
| |
| // table_copy.wast:465 |
| assert_trap(() => call($6, "check_t1", [21])); |
| |
| // table_copy.wast:466 |
| assert_trap(() => call($6, "check_t1", [22])); |
| |
| // table_copy.wast:467 |
| assert_trap(() => call($6, "check_t1", [23])); |
| |
| // table_copy.wast:468 |
| assert_trap(() => call($6, "check_t1", [24])); |
| |
| // table_copy.wast:469 |
| assert_trap(() => call($6, "check_t1", [25])); |
| |
| // table_copy.wast:470 |
| assert_trap(() => call($6, "check_t1", [26])); |
| |
| // table_copy.wast:471 |
| assert_trap(() => call($6, "check_t1", [27])); |
| |
| // table_copy.wast:472 |
| assert_trap(() => call($6, "check_t1", [28])); |
| |
| // table_copy.wast:473 |
| assert_trap(() => call($6, "check_t1", [29])); |
| |
| // table_copy.wast:475 |
| let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:505 |
| run(() => call($7, "test", [])); |
| |
| // table_copy.wast:506 |
| assert_trap(() => call($7, "check_t0", [0])); |
| |
| // table_copy.wast:507 |
| assert_trap(() => call($7, "check_t0", [1])); |
| |
| // table_copy.wast:508 |
| assert_return(() => call($7, "check_t0", [2]), 3); |
| |
| // table_copy.wast:509 |
| assert_return(() => call($7, "check_t0", [3]), 1); |
| |
| // table_copy.wast:510 |
| assert_return(() => call($7, "check_t0", [4]), 4); |
| |
| // table_copy.wast:511 |
| assert_return(() => call($7, "check_t0", [5]), 1); |
| |
| // table_copy.wast:512 |
| assert_trap(() => call($7, "check_t0", [6])); |
| |
| // table_copy.wast:513 |
| assert_trap(() => call($7, "check_t0", [7])); |
| |
| // table_copy.wast:514 |
| assert_trap(() => call($7, "check_t0", [8])); |
| |
| // table_copy.wast:515 |
| assert_trap(() => call($7, "check_t0", [9])); |
| |
| // table_copy.wast:516 |
| assert_trap(() => call($7, "check_t0", [10])); |
| |
| // table_copy.wast:517 |
| assert_trap(() => call($7, "check_t0", [11])); |
| |
| // table_copy.wast:518 |
| assert_return(() => call($7, "check_t0", [12]), 7); |
| |
| // table_copy.wast:519 |
| assert_return(() => call($7, "check_t0", [13]), 5); |
| |
| // table_copy.wast:520 |
| assert_return(() => call($7, "check_t0", [14]), 2); |
| |
| // table_copy.wast:521 |
| assert_return(() => call($7, "check_t0", [15]), 3); |
| |
| // table_copy.wast:522 |
| assert_return(() => call($7, "check_t0", [16]), 6); |
| |
| // table_copy.wast:523 |
| assert_trap(() => call($7, "check_t0", [17])); |
| |
| // table_copy.wast:524 |
| assert_trap(() => call($7, "check_t0", [18])); |
| |
| // table_copy.wast:525 |
| assert_trap(() => call($7, "check_t0", [19])); |
| |
| // table_copy.wast:526 |
| assert_trap(() => call($7, "check_t0", [20])); |
| |
| // table_copy.wast:527 |
| assert_trap(() => call($7, "check_t0", [21])); |
| |
| // table_copy.wast:528 |
| assert_trap(() => call($7, "check_t0", [22])); |
| |
| // table_copy.wast:529 |
| assert_trap(() => call($7, "check_t0", [23])); |
| |
| // table_copy.wast:530 |
| assert_trap(() => call($7, "check_t0", [24])); |
| |
| // table_copy.wast:531 |
| assert_trap(() => call($7, "check_t0", [25])); |
| |
| // table_copy.wast:532 |
| assert_return(() => call($7, "check_t0", [26]), 3); |
| |
| // table_copy.wast:533 |
| assert_return(() => call($7, "check_t0", [27]), 1); |
| |
| // table_copy.wast:534 |
| assert_trap(() => call($7, "check_t0", [28])); |
| |
| // table_copy.wast:535 |
| assert_trap(() => call($7, "check_t0", [29])); |
| |
| // table_copy.wast:536 |
| assert_trap(() => call($7, "check_t1", [0])); |
| |
| // table_copy.wast:537 |
| assert_trap(() => call($7, "check_t1", [1])); |
| |
| // table_copy.wast:538 |
| assert_trap(() => call($7, "check_t1", [2])); |
| |
| // table_copy.wast:539 |
| assert_return(() => call($7, "check_t1", [3]), 1); |
| |
| // table_copy.wast:540 |
| assert_return(() => call($7, "check_t1", [4]), 3); |
| |
| // table_copy.wast:541 |
| assert_return(() => call($7, "check_t1", [5]), 1); |
| |
| // table_copy.wast:542 |
| assert_return(() => call($7, "check_t1", [6]), 4); |
| |
| // table_copy.wast:543 |
| assert_trap(() => call($7, "check_t1", [7])); |
| |
| // table_copy.wast:544 |
| assert_trap(() => call($7, "check_t1", [8])); |
| |
| // table_copy.wast:545 |
| assert_trap(() => call($7, "check_t1", [9])); |
| |
| // table_copy.wast:546 |
| assert_trap(() => call($7, "check_t1", [10])); |
| |
| // table_copy.wast:547 |
| assert_return(() => call($7, "check_t1", [11]), 6); |
| |
| // table_copy.wast:548 |
| assert_return(() => call($7, "check_t1", [12]), 3); |
| |
| // table_copy.wast:549 |
| assert_return(() => call($7, "check_t1", [13]), 2); |
| |
| // table_copy.wast:550 |
| assert_return(() => call($7, "check_t1", [14]), 5); |
| |
| // table_copy.wast:551 |
| assert_return(() => call($7, "check_t1", [15]), 7); |
| |
| // table_copy.wast:552 |
| assert_trap(() => call($7, "check_t1", [16])); |
| |
| // table_copy.wast:553 |
| assert_trap(() => call($7, "check_t1", [17])); |
| |
| // table_copy.wast:554 |
| assert_trap(() => call($7, "check_t1", [18])); |
| |
| // table_copy.wast:555 |
| assert_trap(() => call($7, "check_t1", [19])); |
| |
| // table_copy.wast:556 |
| assert_trap(() => call($7, "check_t1", [20])); |
| |
| // table_copy.wast:557 |
| assert_trap(() => call($7, "check_t1", [21])); |
| |
| // table_copy.wast:558 |
| assert_trap(() => call($7, "check_t1", [22])); |
| |
| // table_copy.wast:559 |
| assert_trap(() => call($7, "check_t1", [23])); |
| |
| // table_copy.wast:560 |
| assert_trap(() => call($7, "check_t1", [24])); |
| |
| // table_copy.wast:561 |
| assert_trap(() => call($7, "check_t1", [25])); |
| |
| // table_copy.wast:562 |
| assert_trap(() => call($7, "check_t1", [26])); |
| |
| // table_copy.wast:563 |
| assert_trap(() => call($7, "check_t1", [27])); |
| |
| // table_copy.wast:564 |
| assert_trap(() => call($7, "check_t1", [28])); |
| |
| // table_copy.wast:565 |
| assert_trap(() => call($7, "check_t1", [29])); |
| |
| // table_copy.wast:567 |
| let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:597 |
| run(() => call($8, "test", [])); |
| |
| // table_copy.wast:598 |
| assert_trap(() => call($8, "check_t0", [0])); |
| |
| // table_copy.wast:599 |
| assert_trap(() => call($8, "check_t0", [1])); |
| |
| // table_copy.wast:600 |
| assert_return(() => call($8, "check_t0", [2]), 3); |
| |
| // table_copy.wast:601 |
| assert_return(() => call($8, "check_t0", [3]), 1); |
| |
| // table_copy.wast:602 |
| assert_return(() => call($8, "check_t0", [4]), 4); |
| |
| // table_copy.wast:603 |
| assert_return(() => call($8, "check_t0", [5]), 1); |
| |
| // table_copy.wast:604 |
| assert_trap(() => call($8, "check_t0", [6])); |
| |
| // table_copy.wast:605 |
| assert_trap(() => call($8, "check_t0", [7])); |
| |
| // table_copy.wast:606 |
| assert_trap(() => call($8, "check_t0", [8])); |
| |
| // table_copy.wast:607 |
| assert_trap(() => call($8, "check_t0", [9])); |
| |
| // table_copy.wast:608 |
| assert_return(() => call($8, "check_t0", [10]), 7); |
| |
| // table_copy.wast:609 |
| assert_return(() => call($8, "check_t0", [11]), 5); |
| |
| // table_copy.wast:610 |
| assert_return(() => call($8, "check_t0", [12]), 2); |
| |
| // table_copy.wast:611 |
| assert_return(() => call($8, "check_t0", [13]), 3); |
| |
| // table_copy.wast:612 |
| assert_return(() => call($8, "check_t0", [14]), 6); |
| |
| // table_copy.wast:613 |
| assert_trap(() => call($8, "check_t0", [15])); |
| |
| // table_copy.wast:614 |
| assert_trap(() => call($8, "check_t0", [16])); |
| |
| // table_copy.wast:615 |
| assert_trap(() => call($8, "check_t0", [17])); |
| |
| // table_copy.wast:616 |
| assert_trap(() => call($8, "check_t0", [18])); |
| |
| // table_copy.wast:617 |
| assert_trap(() => call($8, "check_t0", [19])); |
| |
| // table_copy.wast:618 |
| assert_trap(() => call($8, "check_t0", [20])); |
| |
| // table_copy.wast:619 |
| assert_trap(() => call($8, "check_t0", [21])); |
| |
| // table_copy.wast:620 |
| assert_trap(() => call($8, "check_t0", [22])); |
| |
| // table_copy.wast:621 |
| assert_trap(() => call($8, "check_t0", [23])); |
| |
| // table_copy.wast:622 |
| assert_trap(() => call($8, "check_t0", [24])); |
| |
| // table_copy.wast:623 |
| assert_trap(() => call($8, "check_t0", [25])); |
| |
| // table_copy.wast:624 |
| assert_trap(() => call($8, "check_t0", [26])); |
| |
| // table_copy.wast:625 |
| assert_trap(() => call($8, "check_t0", [27])); |
| |
| // table_copy.wast:626 |
| assert_trap(() => call($8, "check_t0", [28])); |
| |
| // table_copy.wast:627 |
| assert_trap(() => call($8, "check_t0", [29])); |
| |
| // table_copy.wast:628 |
| assert_trap(() => call($8, "check_t1", [0])); |
| |
| // table_copy.wast:629 |
| assert_trap(() => call($8, "check_t1", [1])); |
| |
| // table_copy.wast:630 |
| assert_trap(() => call($8, "check_t1", [2])); |
| |
| // table_copy.wast:631 |
| assert_return(() => call($8, "check_t1", [3]), 1); |
| |
| // table_copy.wast:632 |
| assert_return(() => call($8, "check_t1", [4]), 3); |
| |
| // table_copy.wast:633 |
| assert_return(() => call($8, "check_t1", [5]), 1); |
| |
| // table_copy.wast:634 |
| assert_return(() => call($8, "check_t1", [6]), 4); |
| |
| // table_copy.wast:635 |
| assert_trap(() => call($8, "check_t1", [7])); |
| |
| // table_copy.wast:636 |
| assert_trap(() => call($8, "check_t1", [8])); |
| |
| // table_copy.wast:637 |
| assert_trap(() => call($8, "check_t1", [9])); |
| |
| // table_copy.wast:638 |
| assert_trap(() => call($8, "check_t1", [10])); |
| |
| // table_copy.wast:639 |
| assert_return(() => call($8, "check_t1", [11]), 6); |
| |
| // table_copy.wast:640 |
| assert_return(() => call($8, "check_t1", [12]), 3); |
| |
| // table_copy.wast:641 |
| assert_return(() => call($8, "check_t1", [13]), 2); |
| |
| // table_copy.wast:642 |
| assert_return(() => call($8, "check_t1", [14]), 5); |
| |
| // table_copy.wast:643 |
| assert_return(() => call($8, "check_t1", [15]), 7); |
| |
| // table_copy.wast:644 |
| assert_trap(() => call($8, "check_t1", [16])); |
| |
| // table_copy.wast:645 |
| assert_trap(() => call($8, "check_t1", [17])); |
| |
| // table_copy.wast:646 |
| assert_trap(() => call($8, "check_t1", [18])); |
| |
| // table_copy.wast:647 |
| assert_trap(() => call($8, "check_t1", [19])); |
| |
| // table_copy.wast:648 |
| assert_trap(() => call($8, "check_t1", [20])); |
| |
| // table_copy.wast:649 |
| assert_trap(() => call($8, "check_t1", [21])); |
| |
| // table_copy.wast:650 |
| assert_trap(() => call($8, "check_t1", [22])); |
| |
| // table_copy.wast:651 |
| assert_trap(() => call($8, "check_t1", [23])); |
| |
| // table_copy.wast:652 |
| assert_trap(() => call($8, "check_t1", [24])); |
| |
| // table_copy.wast:653 |
| assert_trap(() => call($8, "check_t1", [25])); |
| |
| // table_copy.wast:654 |
| assert_trap(() => call($8, "check_t1", [26])); |
| |
| // table_copy.wast:655 |
| assert_trap(() => call($8, "check_t1", [27])); |
| |
| // table_copy.wast:656 |
| assert_trap(() => call($8, "check_t1", [28])); |
| |
| // table_copy.wast:657 |
| assert_trap(() => call($8, "check_t1", [29])); |
| |
| // table_copy.wast:659 |
| let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:689 |
| run(() => call($9, "test", [])); |
| |
| // table_copy.wast:690 |
| assert_trap(() => call($9, "check_t0", [0])); |
| |
| // table_copy.wast:691 |
| assert_trap(() => call($9, "check_t0", [1])); |
| |
| // table_copy.wast:692 |
| assert_return(() => call($9, "check_t0", [2]), 3); |
| |
| // table_copy.wast:693 |
| assert_return(() => call($9, "check_t0", [3]), 1); |
| |
| // table_copy.wast:694 |
| assert_return(() => call($9, "check_t0", [4]), 4); |
| |
| // table_copy.wast:695 |
| assert_return(() => call($9, "check_t0", [5]), 1); |
| |
| // table_copy.wast:696 |
| assert_trap(() => call($9, "check_t0", [6])); |
| |
| // table_copy.wast:697 |
| assert_trap(() => call($9, "check_t0", [7])); |
| |
| // table_copy.wast:698 |
| assert_trap(() => call($9, "check_t0", [8])); |
| |
| // table_copy.wast:699 |
| assert_trap(() => call($9, "check_t0", [9])); |
| |
| // table_copy.wast:700 |
| assert_trap(() => call($9, "check_t0", [10])); |
| |
| // table_copy.wast:701 |
| assert_trap(() => call($9, "check_t0", [11])); |
| |
| // table_copy.wast:702 |
| assert_trap(() => call($9, "check_t0", [12])); |
| |
| // table_copy.wast:703 |
| assert_trap(() => call($9, "check_t0", [13])); |
| |
| // table_copy.wast:704 |
| assert_return(() => call($9, "check_t0", [14]), 7); |
| |
| // table_copy.wast:705 |
| assert_return(() => call($9, "check_t0", [15]), 5); |
| |
| // table_copy.wast:706 |
| assert_return(() => call($9, "check_t0", [16]), 2); |
| |
| // table_copy.wast:707 |
| assert_return(() => call($9, "check_t0", [17]), 3); |
| |
| // table_copy.wast:708 |
| assert_return(() => call($9, "check_t0", [18]), 6); |
| |
| // table_copy.wast:709 |
| assert_trap(() => call($9, "check_t0", [19])); |
| |
| // table_copy.wast:710 |
| assert_trap(() => call($9, "check_t0", [20])); |
| |
| // table_copy.wast:711 |
| assert_trap(() => call($9, "check_t0", [21])); |
| |
| // table_copy.wast:712 |
| assert_trap(() => call($9, "check_t0", [22])); |
| |
| // table_copy.wast:713 |
| assert_trap(() => call($9, "check_t0", [23])); |
| |
| // table_copy.wast:714 |
| assert_trap(() => call($9, "check_t0", [24])); |
| |
| // table_copy.wast:715 |
| assert_trap(() => call($9, "check_t0", [25])); |
| |
| // table_copy.wast:716 |
| assert_trap(() => call($9, "check_t0", [26])); |
| |
| // table_copy.wast:717 |
| assert_trap(() => call($9, "check_t0", [27])); |
| |
| // table_copy.wast:718 |
| assert_trap(() => call($9, "check_t0", [28])); |
| |
| // table_copy.wast:719 |
| assert_trap(() => call($9, "check_t0", [29])); |
| |
| // table_copy.wast:720 |
| assert_trap(() => call($9, "check_t1", [0])); |
| |
| // table_copy.wast:721 |
| assert_trap(() => call($9, "check_t1", [1])); |
| |
| // table_copy.wast:722 |
| assert_trap(() => call($9, "check_t1", [2])); |
| |
| // table_copy.wast:723 |
| assert_return(() => call($9, "check_t1", [3]), 1); |
| |
| // table_copy.wast:724 |
| assert_return(() => call($9, "check_t1", [4]), 3); |
| |
| // table_copy.wast:725 |
| assert_return(() => call($9, "check_t1", [5]), 1); |
| |
| // table_copy.wast:726 |
| assert_return(() => call($9, "check_t1", [6]), 4); |
| |
| // table_copy.wast:727 |
| assert_trap(() => call($9, "check_t1", [7])); |
| |
| // table_copy.wast:728 |
| assert_trap(() => call($9, "check_t1", [8])); |
| |
| // table_copy.wast:729 |
| assert_trap(() => call($9, "check_t1", [9])); |
| |
| // table_copy.wast:730 |
| assert_trap(() => call($9, "check_t1", [10])); |
| |
| // table_copy.wast:731 |
| assert_return(() => call($9, "check_t1", [11]), 6); |
| |
| // table_copy.wast:732 |
| assert_return(() => call($9, "check_t1", [12]), 3); |
| |
| // table_copy.wast:733 |
| assert_return(() => call($9, "check_t1", [13]), 2); |
| |
| // table_copy.wast:734 |
| assert_return(() => call($9, "check_t1", [14]), 5); |
| |
| // table_copy.wast:735 |
| assert_return(() => call($9, "check_t1", [15]), 7); |
| |
| // table_copy.wast:736 |
| assert_trap(() => call($9, "check_t1", [16])); |
| |
| // table_copy.wast:737 |
| assert_trap(() => call($9, "check_t1", [17])); |
| |
| // table_copy.wast:738 |
| assert_trap(() => call($9, "check_t1", [18])); |
| |
| // table_copy.wast:739 |
| assert_trap(() => call($9, "check_t1", [19])); |
| |
| // table_copy.wast:740 |
| assert_trap(() => call($9, "check_t1", [20])); |
| |
| // table_copy.wast:741 |
| assert_trap(() => call($9, "check_t1", [21])); |
| |
| // table_copy.wast:742 |
| assert_trap(() => call($9, "check_t1", [22])); |
| |
| // table_copy.wast:743 |
| assert_trap(() => call($9, "check_t1", [23])); |
| |
| // table_copy.wast:744 |
| assert_trap(() => call($9, "check_t1", [24])); |
| |
| // table_copy.wast:745 |
| assert_trap(() => call($9, "check_t1", [25])); |
| |
| // table_copy.wast:746 |
| assert_trap(() => call($9, "check_t1", [26])); |
| |
| // table_copy.wast:747 |
| assert_trap(() => call($9, "check_t1", [27])); |
| |
| // table_copy.wast:748 |
| assert_trap(() => call($9, "check_t1", [28])); |
| |
| // table_copy.wast:749 |
| assert_trap(() => call($9, "check_t1", [29])); |
| |
| // table_copy.wast:751 |
| let $10 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x01\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b"); |
| |
| // table_copy.wast:781 |
| run(() => call($10, "test", [])); |
| |
| // table_copy.wast:782 |
| assert_trap(() => call($10, "check_t0", [0])); |
| |
| // table_copy.wast:783 |
| assert_trap(() => call($10, "check_t0", [1])); |
| |
| // table_copy.wast:784 |
| assert_return(() => call($10, "check_t0", [2]), 3); |
| |
| // table_copy.wast:785 |
| assert_return(() => call($10, "check_t0", [3]), 1); |
| |
| // table_copy.wast:786 |
| assert_return(() => call($10, "check_t0", [4]), 4); |
| |
| // table_copy.wast:787 |
| assert_return(() => call($10, "check_t0", [5]), 1); |
| |
| // table_copy.wast:788 |
| assert_trap(() => call($10, "check_t0", [6])); |
| |
| // table_copy.wast:789 |
| assert_trap(() => call($10, "check_t0", [7])); |
| |
| // table_copy.wast:790 |
| assert_trap(() => call($10, "check_t0", [8])); |
| |
| // table_copy.wast:791 |
| assert_trap(() => call($10, "check_t0", [9])); |
| |
| // table_copy.wast:792 |
| assert_trap(() => call($10, "check_t0", [10])); |
| |
| // table_copy.wast:793 |
| assert_trap(() => call($10, "check_t0", [11])); |
| |
| // table_copy.wast:794 |
| assert_return(() => call($10, "check_t0", [12]), 7); |
| |
| // table_copy.wast:795 |
| assert_return(() => call($10, "check_t0", [13]), 5); |
| |
| // table_copy.wast:796 |
| assert_return(() => call($10, "check_t0", [14]), 2); |
| |
| // table_copy.wast:797 |
| assert_return(() => call($10, "check_t0", [15]), 3); |
| |
| // table_copy.wast:798 |
| assert_return(() => call($10, "check_t0", [16]), 6); |
| |
| // table_copy.wast:799 |
| assert_trap(() => call($10, "check_t0", [17])); |
| |
| // table_copy.wast:800 |
| assert_trap(() => call($10, "check_t0", [18])); |
| |
| // table_copy.wast:801 |
| assert_trap(() => call($10, "check_t0", [19])); |
| |
| // table_copy.wast:802 |
| assert_trap(() => call($10, "check_t0", [20])); |
| |
| // table_copy.wast:803 |
| assert_trap(() => call($10, "check_t0", [21])); |
| |
| // table_copy.wast:804 |
| assert_trap(() => call($10, "check_t0", [22])); |
| |
| // table_copy.wast:805 |
| assert_trap(() => call($10, "check_t0", [23])); |
| |
| // table_copy.wast:806 |
| assert_trap(() => call($10, "check_t0", [24])); |
| |
| // table_copy.wast:807 |
| assert_trap(() => call($10, "check_t0", [25])); |
| |
| // table_copy.wast:808 |
| assert_trap(() => call($10, "check_t0", [26])); |
| |
| // table_copy.wast:809 |
| assert_trap(() => call($10, "check_t0", [27])); |
| |
| // table_copy.wast:810 |
| assert_trap(() => call($10, "check_t0", [28])); |
| |
| // table_copy.wast:811 |
| assert_trap(() => call($10, "check_t0", [29])); |
| |
| // table_copy.wast:812 |
| assert_trap(() => call($10, "check_t1", [0])); |
| |
| // table_copy.wast:813 |
| assert_trap(() => call($10, "check_t1", [1])); |
| |
| // table_copy.wast:814 |
| assert_trap(() => call($10, "check_t1", [2])); |
| |
| // table_copy.wast:815 |
| assert_return(() => call($10, "check_t1", [3]), 1); |
| |
| // table_copy.wast:816 |
| assert_return(() => call($10, "check_t1", [4]), 3); |
| |
| // table_copy.wast:817 |
| assert_return(() => call($10, "check_t1", [5]), 1); |
| |
| // table_copy.wast:818 |
| assert_return(() => call($10, "check_t1", [6]), 4); |
| |
| // table_copy.wast:819 |
| assert_trap(() => call($10, "check_t1", [7])); |
| |
| // table_copy.wast:820 |
| assert_trap(() => call($10, "check_t1", [8])); |
| |
| // table_copy.wast:821 |
| assert_trap(() => call($10, "check_t1", [9])); |
| |
| // table_copy.wast:822 |
| assert_trap(() => call($10, "check_t1", [10])); |
| |
| // table_copy.wast:823 |
| assert_trap(() => call($10, "check_t1", [11])); |
| |
| // table_copy.wast:824 |
| assert_return(() => call($10, "check_t1", [12]), 3); |
| |
| // table_copy.wast:825 |
| assert_return(() => call($10, "check_t1", [13]), 1); |
| |
| // table_copy.wast:826 |
| assert_return(() => call($10, "check_t1", [14]), 4); |
| |
| // table_copy.wast:827 |
| assert_return(() => call($10, "check_t1", [15]), 1); |
| |
| // table_copy.wast:828 |
| assert_trap(() => call($10, "check_t1", [16])); |
| |
| // table_copy.wast:829 |
| assert_trap(() => call($10, "check_t1", [17])); |
| |
| // table_copy.wast:830 |
| assert_trap(() => call($10, "check_t1", [18])); |
| |
| // table_copy.wast:831 |
| assert_trap(() => call($10, "check_t1", [19])); |
| |
| // table_copy.wast:832 |
| assert_trap(() => call($10, "check_t1", [20])); |
| |
| // table_copy.wast:833 |
| assert_trap(() => call($10, "check_t1", [21])); |
| |
| // table_copy.wast:834 |
| assert_return(() => call($10, "check_t1", [22]), 7); |
| |
| // table_copy.wast:835 |
| assert_return(() => call($10, "check_t1", [23]), 5); |
| |
| // table_copy.wast:836 |
| assert_return(() => call($10, "check_t1", [24]), 2); |
| |
| // table_copy.wast:837 |
| assert_return(() => call($10, "check_t1", [25]), 3); |
| |
| // table_copy.wast:838 |
| assert_return(() => call($10, "check_t1", [26]), 6); |
| |
| // table_copy.wast:839 |
| assert_trap(() => call($10, "check_t1", [27])); |
| |
| // table_copy.wast:840 |
| assert_trap(() => call($10, "check_t1", [28])); |
| |
| // table_copy.wast:841 |
| assert_trap(() => call($10, "check_t1", [29])); |
| |
| // table_copy.wast:843 |
| let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:873 |
| run(() => call($11, "test", [])); |
| |
| // table_copy.wast:874 |
| assert_trap(() => call($11, "check_t0", [0])); |
| |
| // table_copy.wast:875 |
| assert_trap(() => call($11, "check_t0", [1])); |
| |
| // table_copy.wast:876 |
| assert_return(() => call($11, "check_t0", [2]), 3); |
| |
| // table_copy.wast:877 |
| assert_return(() => call($11, "check_t0", [3]), 1); |
| |
| // table_copy.wast:878 |
| assert_return(() => call($11, "check_t0", [4]), 4); |
| |
| // table_copy.wast:879 |
| assert_return(() => call($11, "check_t0", [5]), 1); |
| |
| // table_copy.wast:880 |
| assert_trap(() => call($11, "check_t0", [6])); |
| |
| // table_copy.wast:881 |
| assert_trap(() => call($11, "check_t0", [7])); |
| |
| // table_copy.wast:882 |
| assert_trap(() => call($11, "check_t0", [8])); |
| |
| // table_copy.wast:883 |
| assert_trap(() => call($11, "check_t0", [9])); |
| |
| // table_copy.wast:884 |
| assert_trap(() => call($11, "check_t0", [10])); |
| |
| // table_copy.wast:885 |
| assert_trap(() => call($11, "check_t0", [11])); |
| |
| // table_copy.wast:886 |
| assert_return(() => call($11, "check_t0", [12]), 7); |
| |
| // table_copy.wast:887 |
| assert_return(() => call($11, "check_t0", [13]), 5); |
| |
| // table_copy.wast:888 |
| assert_return(() => call($11, "check_t0", [14]), 2); |
| |
| // table_copy.wast:889 |
| assert_return(() => call($11, "check_t0", [15]), 3); |
| |
| // table_copy.wast:890 |
| assert_return(() => call($11, "check_t0", [16]), 6); |
| |
| // table_copy.wast:891 |
| assert_trap(() => call($11, "check_t0", [17])); |
| |
| // table_copy.wast:892 |
| assert_trap(() => call($11, "check_t0", [18])); |
| |
| // table_copy.wast:893 |
| assert_trap(() => call($11, "check_t0", [19])); |
| |
| // table_copy.wast:894 |
| assert_trap(() => call($11, "check_t0", [20])); |
| |
| // table_copy.wast:895 |
| assert_trap(() => call($11, "check_t0", [21])); |
| |
| // table_copy.wast:896 |
| assert_trap(() => call($11, "check_t0", [22])); |
| |
| // table_copy.wast:897 |
| assert_trap(() => call($11, "check_t0", [23])); |
| |
| // table_copy.wast:898 |
| assert_trap(() => call($11, "check_t0", [24])); |
| |
| // table_copy.wast:899 |
| assert_trap(() => call($11, "check_t0", [25])); |
| |
| // table_copy.wast:900 |
| assert_trap(() => call($11, "check_t0", [26])); |
| |
| // table_copy.wast:901 |
| assert_trap(() => call($11, "check_t0", [27])); |
| |
| // table_copy.wast:902 |
| assert_trap(() => call($11, "check_t0", [28])); |
| |
| // table_copy.wast:903 |
| assert_trap(() => call($11, "check_t0", [29])); |
| |
| // table_copy.wast:904 |
| assert_trap(() => call($11, "check_t1", [0])); |
| |
| // table_copy.wast:905 |
| assert_trap(() => call($11, "check_t1", [1])); |
| |
| // table_copy.wast:906 |
| assert_trap(() => call($11, "check_t1", [2])); |
| |
| // table_copy.wast:907 |
| assert_return(() => call($11, "check_t1", [3]), 1); |
| |
| // table_copy.wast:908 |
| assert_return(() => call($11, "check_t1", [4]), 3); |
| |
| // table_copy.wast:909 |
| assert_return(() => call($11, "check_t1", [5]), 1); |
| |
| // table_copy.wast:910 |
| assert_return(() => call($11, "check_t1", [6]), 4); |
| |
| // table_copy.wast:911 |
| assert_trap(() => call($11, "check_t1", [7])); |
| |
| // table_copy.wast:912 |
| assert_trap(() => call($11, "check_t1", [8])); |
| |
| // table_copy.wast:913 |
| assert_trap(() => call($11, "check_t1", [9])); |
| |
| // table_copy.wast:914 |
| assert_trap(() => call($11, "check_t1", [10])); |
| |
| // table_copy.wast:915 |
| assert_return(() => call($11, "check_t1", [11]), 6); |
| |
| // table_copy.wast:916 |
| assert_return(() => call($11, "check_t1", [12]), 3); |
| |
| // table_copy.wast:917 |
| assert_return(() => call($11, "check_t1", [13]), 2); |
| |
| // table_copy.wast:918 |
| assert_return(() => call($11, "check_t1", [14]), 5); |
| |
| // table_copy.wast:919 |
| assert_return(() => call($11, "check_t1", [15]), 7); |
| |
| // table_copy.wast:920 |
| assert_trap(() => call($11, "check_t1", [16])); |
| |
| // table_copy.wast:921 |
| assert_trap(() => call($11, "check_t1", [17])); |
| |
| // table_copy.wast:922 |
| assert_trap(() => call($11, "check_t1", [18])); |
| |
| // table_copy.wast:923 |
| assert_trap(() => call($11, "check_t1", [19])); |
| |
| // table_copy.wast:924 |
| assert_trap(() => call($11, "check_t1", [20])); |
| |
| // table_copy.wast:925 |
| assert_trap(() => call($11, "check_t1", [21])); |
| |
| // table_copy.wast:926 |
| assert_trap(() => call($11, "check_t1", [22])); |
| |
| // table_copy.wast:927 |
| assert_trap(() => call($11, "check_t1", [23])); |
| |
| // table_copy.wast:928 |
| assert_trap(() => call($11, "check_t1", [24])); |
| |
| // table_copy.wast:929 |
| assert_trap(() => call($11, "check_t1", [25])); |
| |
| // table_copy.wast:930 |
| assert_trap(() => call($11, "check_t1", [26])); |
| |
| // table_copy.wast:931 |
| assert_trap(() => call($11, "check_t1", [27])); |
| |
| // table_copy.wast:932 |
| assert_trap(() => call($11, "check_t1", [28])); |
| |
| // table_copy.wast:933 |
| assert_trap(() => call($11, "check_t1", [29])); |
| |
| // table_copy.wast:935 |
| let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:965 |
| run(() => call($12, "test", [])); |
| |
| // table_copy.wast:966 |
| assert_trap(() => call($12, "check_t0", [0])); |
| |
| // table_copy.wast:967 |
| assert_trap(() => call($12, "check_t0", [1])); |
| |
| // table_copy.wast:968 |
| assert_return(() => call($12, "check_t0", [2]), 3); |
| |
| // table_copy.wast:969 |
| assert_return(() => call($12, "check_t0", [3]), 1); |
| |
| // table_copy.wast:970 |
| assert_return(() => call($12, "check_t0", [4]), 4); |
| |
| // table_copy.wast:971 |
| assert_return(() => call($12, "check_t0", [5]), 1); |
| |
| // table_copy.wast:972 |
| assert_trap(() => call($12, "check_t0", [6])); |
| |
| // table_copy.wast:973 |
| assert_trap(() => call($12, "check_t0", [7])); |
| |
| // table_copy.wast:974 |
| assert_trap(() => call($12, "check_t0", [8])); |
| |
| // table_copy.wast:975 |
| assert_trap(() => call($12, "check_t0", [9])); |
| |
| // table_copy.wast:976 |
| assert_trap(() => call($12, "check_t0", [10])); |
| |
| // table_copy.wast:977 |
| assert_trap(() => call($12, "check_t0", [11])); |
| |
| // table_copy.wast:978 |
| assert_return(() => call($12, "check_t0", [12]), 7); |
| |
| // table_copy.wast:979 |
| assert_return(() => call($12, "check_t0", [13]), 3); |
| |
| // table_copy.wast:980 |
| assert_return(() => call($12, "check_t0", [14]), 1); |
| |
| // table_copy.wast:981 |
| assert_return(() => call($12, "check_t0", [15]), 4); |
| |
| // table_copy.wast:982 |
| assert_return(() => call($12, "check_t0", [16]), 6); |
| |
| // table_copy.wast:983 |
| assert_trap(() => call($12, "check_t0", [17])); |
| |
| // table_copy.wast:984 |
| assert_trap(() => call($12, "check_t0", [18])); |
| |
| // table_copy.wast:985 |
| assert_trap(() => call($12, "check_t0", [19])); |
| |
| // table_copy.wast:986 |
| assert_trap(() => call($12, "check_t0", [20])); |
| |
| // table_copy.wast:987 |
| assert_trap(() => call($12, "check_t0", [21])); |
| |
| // table_copy.wast:988 |
| assert_trap(() => call($12, "check_t0", [22])); |
| |
| // table_copy.wast:989 |
| assert_trap(() => call($12, "check_t0", [23])); |
| |
| // table_copy.wast:990 |
| assert_trap(() => call($12, "check_t0", [24])); |
| |
| // table_copy.wast:991 |
| assert_trap(() => call($12, "check_t0", [25])); |
| |
| // table_copy.wast:992 |
| assert_trap(() => call($12, "check_t0", [26])); |
| |
| // table_copy.wast:993 |
| assert_trap(() => call($12, "check_t0", [27])); |
| |
| // table_copy.wast:994 |
| assert_trap(() => call($12, "check_t0", [28])); |
| |
| // table_copy.wast:995 |
| assert_trap(() => call($12, "check_t0", [29])); |
| |
| // table_copy.wast:996 |
| assert_trap(() => call($12, "check_t1", [0])); |
| |
| // table_copy.wast:997 |
| assert_trap(() => call($12, "check_t1", [1])); |
| |
| // table_copy.wast:998 |
| assert_trap(() => call($12, "check_t1", [2])); |
| |
| // table_copy.wast:999 |
| assert_return(() => call($12, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1000 |
| assert_return(() => call($12, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1001 |
| assert_return(() => call($12, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1002 |
| assert_return(() => call($12, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1003 |
| assert_trap(() => call($12, "check_t1", [7])); |
| |
| // table_copy.wast:1004 |
| assert_trap(() => call($12, "check_t1", [8])); |
| |
| // table_copy.wast:1005 |
| assert_trap(() => call($12, "check_t1", [9])); |
| |
| // table_copy.wast:1006 |
| assert_trap(() => call($12, "check_t1", [10])); |
| |
| // table_copy.wast:1007 |
| assert_return(() => call($12, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1008 |
| assert_return(() => call($12, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1009 |
| assert_return(() => call($12, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1010 |
| assert_return(() => call($12, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1011 |
| assert_return(() => call($12, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1012 |
| assert_trap(() => call($12, "check_t1", [16])); |
| |
| // table_copy.wast:1013 |
| assert_trap(() => call($12, "check_t1", [17])); |
| |
| // table_copy.wast:1014 |
| assert_trap(() => call($12, "check_t1", [18])); |
| |
| // table_copy.wast:1015 |
| assert_trap(() => call($12, "check_t1", [19])); |
| |
| // table_copy.wast:1016 |
| assert_trap(() => call($12, "check_t1", [20])); |
| |
| // table_copy.wast:1017 |
| assert_trap(() => call($12, "check_t1", [21])); |
| |
| // table_copy.wast:1018 |
| assert_trap(() => call($12, "check_t1", [22])); |
| |
| // table_copy.wast:1019 |
| assert_trap(() => call($12, "check_t1", [23])); |
| |
| // table_copy.wast:1020 |
| assert_trap(() => call($12, "check_t1", [24])); |
| |
| // table_copy.wast:1021 |
| assert_trap(() => call($12, "check_t1", [25])); |
| |
| // table_copy.wast:1022 |
| assert_trap(() => call($12, "check_t1", [26])); |
| |
| // table_copy.wast:1023 |
| assert_trap(() => call($12, "check_t1", [27])); |
| |
| // table_copy.wast:1024 |
| assert_trap(() => call($12, "check_t1", [28])); |
| |
| // table_copy.wast:1025 |
| assert_trap(() => call($12, "check_t1", [29])); |
| |
| // table_copy.wast:1027 |
| let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1057 |
| run(() => call($13, "test", [])); |
| |
| // table_copy.wast:1058 |
| assert_trap(() => call($13, "check_t0", [0])); |
| |
| // table_copy.wast:1059 |
| assert_trap(() => call($13, "check_t0", [1])); |
| |
| // table_copy.wast:1060 |
| assert_return(() => call($13, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1061 |
| assert_return(() => call($13, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1062 |
| assert_return(() => call($13, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1063 |
| assert_return(() => call($13, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1064 |
| assert_trap(() => call($13, "check_t0", [6])); |
| |
| // table_copy.wast:1065 |
| assert_trap(() => call($13, "check_t0", [7])); |
| |
| // table_copy.wast:1066 |
| assert_trap(() => call($13, "check_t0", [8])); |
| |
| // table_copy.wast:1067 |
| assert_trap(() => call($13, "check_t0", [9])); |
| |
| // table_copy.wast:1068 |
| assert_trap(() => call($13, "check_t0", [10])); |
| |
| // table_copy.wast:1069 |
| assert_trap(() => call($13, "check_t0", [11])); |
| |
| // table_copy.wast:1070 |
| assert_return(() => call($13, "check_t0", [12]), 7); |
| |
| // table_copy.wast:1071 |
| assert_return(() => call($13, "check_t0", [13]), 5); |
| |
| // table_copy.wast:1072 |
| assert_return(() => call($13, "check_t0", [14]), 2); |
| |
| // table_copy.wast:1073 |
| assert_return(() => call($13, "check_t0", [15]), 3); |
| |
| // table_copy.wast:1074 |
| assert_return(() => call($13, "check_t0", [16]), 6); |
| |
| // table_copy.wast:1075 |
| assert_trap(() => call($13, "check_t0", [17])); |
| |
| // table_copy.wast:1076 |
| assert_trap(() => call($13, "check_t0", [18])); |
| |
| // table_copy.wast:1077 |
| assert_trap(() => call($13, "check_t0", [19])); |
| |
| // table_copy.wast:1078 |
| assert_trap(() => call($13, "check_t0", [20])); |
| |
| // table_copy.wast:1079 |
| assert_trap(() => call($13, "check_t0", [21])); |
| |
| // table_copy.wast:1080 |
| assert_trap(() => call($13, "check_t0", [22])); |
| |
| // table_copy.wast:1081 |
| assert_trap(() => call($13, "check_t0", [23])); |
| |
| // table_copy.wast:1082 |
| assert_trap(() => call($13, "check_t0", [24])); |
| |
| // table_copy.wast:1083 |
| assert_return(() => call($13, "check_t0", [25]), 3); |
| |
| // table_copy.wast:1084 |
| assert_return(() => call($13, "check_t0", [26]), 6); |
| |
| // table_copy.wast:1085 |
| assert_trap(() => call($13, "check_t0", [27])); |
| |
| // table_copy.wast:1086 |
| assert_trap(() => call($13, "check_t0", [28])); |
| |
| // table_copy.wast:1087 |
| assert_trap(() => call($13, "check_t0", [29])); |
| |
| // table_copy.wast:1088 |
| assert_trap(() => call($13, "check_t1", [0])); |
| |
| // table_copy.wast:1089 |
| assert_trap(() => call($13, "check_t1", [1])); |
| |
| // table_copy.wast:1090 |
| assert_trap(() => call($13, "check_t1", [2])); |
| |
| // table_copy.wast:1091 |
| assert_return(() => call($13, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1092 |
| assert_return(() => call($13, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1093 |
| assert_return(() => call($13, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1094 |
| assert_return(() => call($13, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1095 |
| assert_trap(() => call($13, "check_t1", [7])); |
| |
| // table_copy.wast:1096 |
| assert_trap(() => call($13, "check_t1", [8])); |
| |
| // table_copy.wast:1097 |
| assert_trap(() => call($13, "check_t1", [9])); |
| |
| // table_copy.wast:1098 |
| assert_trap(() => call($13, "check_t1", [10])); |
| |
| // table_copy.wast:1099 |
| assert_return(() => call($13, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1100 |
| assert_return(() => call($13, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1101 |
| assert_return(() => call($13, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1102 |
| assert_return(() => call($13, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1103 |
| assert_return(() => call($13, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1104 |
| assert_trap(() => call($13, "check_t1", [16])); |
| |
| // table_copy.wast:1105 |
| assert_trap(() => call($13, "check_t1", [17])); |
| |
| // table_copy.wast:1106 |
| assert_trap(() => call($13, "check_t1", [18])); |
| |
| // table_copy.wast:1107 |
| assert_trap(() => call($13, "check_t1", [19])); |
| |
| // table_copy.wast:1108 |
| assert_trap(() => call($13, "check_t1", [20])); |
| |
| // table_copy.wast:1109 |
| assert_trap(() => call($13, "check_t1", [21])); |
| |
| // table_copy.wast:1110 |
| assert_trap(() => call($13, "check_t1", [22])); |
| |
| // table_copy.wast:1111 |
| assert_trap(() => call($13, "check_t1", [23])); |
| |
| // table_copy.wast:1112 |
| assert_trap(() => call($13, "check_t1", [24])); |
| |
| // table_copy.wast:1113 |
| assert_trap(() => call($13, "check_t1", [25])); |
| |
| // table_copy.wast:1114 |
| assert_trap(() => call($13, "check_t1", [26])); |
| |
| // table_copy.wast:1115 |
| assert_trap(() => call($13, "check_t1", [27])); |
| |
| // table_copy.wast:1116 |
| assert_trap(() => call($13, "check_t1", [28])); |
| |
| // table_copy.wast:1117 |
| assert_trap(() => call($13, "check_t1", [29])); |
| |
| // table_copy.wast:1119 |
| let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1149 |
| run(() => call($14, "test", [])); |
| |
| // table_copy.wast:1150 |
| assert_trap(() => call($14, "check_t0", [0])); |
| |
| // table_copy.wast:1151 |
| assert_trap(() => call($14, "check_t0", [1])); |
| |
| // table_copy.wast:1152 |
| assert_return(() => call($14, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1153 |
| assert_return(() => call($14, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1154 |
| assert_return(() => call($14, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1155 |
| assert_return(() => call($14, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1156 |
| assert_trap(() => call($14, "check_t0", [6])); |
| |
| // table_copy.wast:1157 |
| assert_trap(() => call($14, "check_t0", [7])); |
| |
| // table_copy.wast:1158 |
| assert_trap(() => call($14, "check_t0", [8])); |
| |
| // table_copy.wast:1159 |
| assert_trap(() => call($14, "check_t0", [9])); |
| |
| // table_copy.wast:1160 |
| assert_trap(() => call($14, "check_t0", [10])); |
| |
| // table_copy.wast:1161 |
| assert_trap(() => call($14, "check_t0", [11])); |
| |
| // table_copy.wast:1162 |
| assert_return(() => call($14, "check_t0", [12]), 7); |
| |
| // table_copy.wast:1163 |
| assert_trap(() => call($14, "check_t0", [13])); |
| |
| // table_copy.wast:1164 |
| assert_trap(() => call($14, "check_t0", [14])); |
| |
| // table_copy.wast:1165 |
| assert_trap(() => call($14, "check_t0", [15])); |
| |
| // table_copy.wast:1166 |
| assert_return(() => call($14, "check_t0", [16]), 6); |
| |
| // table_copy.wast:1167 |
| assert_trap(() => call($14, "check_t0", [17])); |
| |
| // table_copy.wast:1168 |
| assert_trap(() => call($14, "check_t0", [18])); |
| |
| // table_copy.wast:1169 |
| assert_trap(() => call($14, "check_t0", [19])); |
| |
| // table_copy.wast:1170 |
| assert_trap(() => call($14, "check_t0", [20])); |
| |
| // table_copy.wast:1171 |
| assert_trap(() => call($14, "check_t0", [21])); |
| |
| // table_copy.wast:1172 |
| assert_trap(() => call($14, "check_t0", [22])); |
| |
| // table_copy.wast:1173 |
| assert_trap(() => call($14, "check_t0", [23])); |
| |
| // table_copy.wast:1174 |
| assert_trap(() => call($14, "check_t0", [24])); |
| |
| // table_copy.wast:1175 |
| assert_trap(() => call($14, "check_t0", [25])); |
| |
| // table_copy.wast:1176 |
| assert_trap(() => call($14, "check_t0", [26])); |
| |
| // table_copy.wast:1177 |
| assert_trap(() => call($14, "check_t0", [27])); |
| |
| // table_copy.wast:1178 |
| assert_trap(() => call($14, "check_t0", [28])); |
| |
| // table_copy.wast:1179 |
| assert_trap(() => call($14, "check_t0", [29])); |
| |
| // table_copy.wast:1180 |
| assert_trap(() => call($14, "check_t1", [0])); |
| |
| // table_copy.wast:1181 |
| assert_trap(() => call($14, "check_t1", [1])); |
| |
| // table_copy.wast:1182 |
| assert_trap(() => call($14, "check_t1", [2])); |
| |
| // table_copy.wast:1183 |
| assert_return(() => call($14, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1184 |
| assert_return(() => call($14, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1185 |
| assert_return(() => call($14, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1186 |
| assert_return(() => call($14, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1187 |
| assert_trap(() => call($14, "check_t1", [7])); |
| |
| // table_copy.wast:1188 |
| assert_trap(() => call($14, "check_t1", [8])); |
| |
| // table_copy.wast:1189 |
| assert_trap(() => call($14, "check_t1", [9])); |
| |
| // table_copy.wast:1190 |
| assert_trap(() => call($14, "check_t1", [10])); |
| |
| // table_copy.wast:1191 |
| assert_return(() => call($14, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1192 |
| assert_return(() => call($14, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1193 |
| assert_return(() => call($14, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1194 |
| assert_return(() => call($14, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1195 |
| assert_return(() => call($14, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1196 |
| assert_trap(() => call($14, "check_t1", [16])); |
| |
| // table_copy.wast:1197 |
| assert_trap(() => call($14, "check_t1", [17])); |
| |
| // table_copy.wast:1198 |
| assert_trap(() => call($14, "check_t1", [18])); |
| |
| // table_copy.wast:1199 |
| assert_trap(() => call($14, "check_t1", [19])); |
| |
| // table_copy.wast:1200 |
| assert_trap(() => call($14, "check_t1", [20])); |
| |
| // table_copy.wast:1201 |
| assert_trap(() => call($14, "check_t1", [21])); |
| |
| // table_copy.wast:1202 |
| assert_trap(() => call($14, "check_t1", [22])); |
| |
| // table_copy.wast:1203 |
| assert_trap(() => call($14, "check_t1", [23])); |
| |
| // table_copy.wast:1204 |
| assert_trap(() => call($14, "check_t1", [24])); |
| |
| // table_copy.wast:1205 |
| assert_trap(() => call($14, "check_t1", [25])); |
| |
| // table_copy.wast:1206 |
| assert_trap(() => call($14, "check_t1", [26])); |
| |
| // table_copy.wast:1207 |
| assert_trap(() => call($14, "check_t1", [27])); |
| |
| // table_copy.wast:1208 |
| assert_trap(() => call($14, "check_t1", [28])); |
| |
| // table_copy.wast:1209 |
| assert_trap(() => call($14, "check_t1", [29])); |
| |
| // table_copy.wast:1211 |
| let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1241 |
| run(() => call($15, "test", [])); |
| |
| // table_copy.wast:1242 |
| assert_trap(() => call($15, "check_t0", [0])); |
| |
| // table_copy.wast:1243 |
| assert_trap(() => call($15, "check_t0", [1])); |
| |
| // table_copy.wast:1244 |
| assert_return(() => call($15, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1245 |
| assert_return(() => call($15, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1246 |
| assert_return(() => call($15, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1247 |
| assert_return(() => call($15, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1248 |
| assert_trap(() => call($15, "check_t0", [6])); |
| |
| // table_copy.wast:1249 |
| assert_trap(() => call($15, "check_t0", [7])); |
| |
| // table_copy.wast:1250 |
| assert_trap(() => call($15, "check_t0", [8])); |
| |
| // table_copy.wast:1251 |
| assert_trap(() => call($15, "check_t0", [9])); |
| |
| // table_copy.wast:1252 |
| assert_trap(() => call($15, "check_t0", [10])); |
| |
| // table_copy.wast:1253 |
| assert_trap(() => call($15, "check_t0", [11])); |
| |
| // table_copy.wast:1254 |
| assert_return(() => call($15, "check_t0", [12]), 7); |
| |
| // table_copy.wast:1255 |
| assert_return(() => call($15, "check_t0", [13]), 5); |
| |
| // table_copy.wast:1256 |
| assert_return(() => call($15, "check_t0", [14]), 2); |
| |
| // table_copy.wast:1257 |
| assert_return(() => call($15, "check_t0", [15]), 3); |
| |
| // table_copy.wast:1258 |
| assert_return(() => call($15, "check_t0", [16]), 6); |
| |
| // table_copy.wast:1259 |
| assert_trap(() => call($15, "check_t0", [17])); |
| |
| // table_copy.wast:1260 |
| assert_trap(() => call($15, "check_t0", [18])); |
| |
| // table_copy.wast:1261 |
| assert_trap(() => call($15, "check_t0", [19])); |
| |
| // table_copy.wast:1262 |
| assert_trap(() => call($15, "check_t0", [20])); |
| |
| // table_copy.wast:1263 |
| assert_trap(() => call($15, "check_t0", [21])); |
| |
| // table_copy.wast:1264 |
| assert_trap(() => call($15, "check_t0", [22])); |
| |
| // table_copy.wast:1265 |
| assert_trap(() => call($15, "check_t0", [23])); |
| |
| // table_copy.wast:1266 |
| assert_trap(() => call($15, "check_t0", [24])); |
| |
| // table_copy.wast:1267 |
| assert_trap(() => call($15, "check_t0", [25])); |
| |
| // table_copy.wast:1268 |
| assert_trap(() => call($15, "check_t0", [26])); |
| |
| // table_copy.wast:1269 |
| assert_trap(() => call($15, "check_t0", [27])); |
| |
| // table_copy.wast:1270 |
| assert_trap(() => call($15, "check_t0", [28])); |
| |
| // table_copy.wast:1271 |
| assert_trap(() => call($15, "check_t0", [29])); |
| |
| // table_copy.wast:1272 |
| assert_trap(() => call($15, "check_t1", [0])); |
| |
| // table_copy.wast:1273 |
| assert_trap(() => call($15, "check_t1", [1])); |
| |
| // table_copy.wast:1274 |
| assert_trap(() => call($15, "check_t1", [2])); |
| |
| // table_copy.wast:1275 |
| assert_return(() => call($15, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1276 |
| assert_return(() => call($15, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1277 |
| assert_return(() => call($15, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1278 |
| assert_return(() => call($15, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1279 |
| assert_trap(() => call($15, "check_t1", [7])); |
| |
| // table_copy.wast:1280 |
| assert_trap(() => call($15, "check_t1", [8])); |
| |
| // table_copy.wast:1281 |
| assert_trap(() => call($15, "check_t1", [9])); |
| |
| // table_copy.wast:1282 |
| assert_trap(() => call($15, "check_t1", [10])); |
| |
| // table_copy.wast:1283 |
| assert_return(() => call($15, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1284 |
| assert_return(() => call($15, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1285 |
| assert_return(() => call($15, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1286 |
| assert_return(() => call($15, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1287 |
| assert_return(() => call($15, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1288 |
| assert_trap(() => call($15, "check_t1", [16])); |
| |
| // table_copy.wast:1289 |
| assert_trap(() => call($15, "check_t1", [17])); |
| |
| // table_copy.wast:1290 |
| assert_trap(() => call($15, "check_t1", [18])); |
| |
| // table_copy.wast:1291 |
| assert_trap(() => call($15, "check_t1", [19])); |
| |
| // table_copy.wast:1292 |
| assert_trap(() => call($15, "check_t1", [20])); |
| |
| // table_copy.wast:1293 |
| assert_trap(() => call($15, "check_t1", [21])); |
| |
| // table_copy.wast:1294 |
| assert_trap(() => call($15, "check_t1", [22])); |
| |
| // table_copy.wast:1295 |
| assert_trap(() => call($15, "check_t1", [23])); |
| |
| // table_copy.wast:1296 |
| assert_trap(() => call($15, "check_t1", [24])); |
| |
| // table_copy.wast:1297 |
| assert_trap(() => call($15, "check_t1", [25])); |
| |
| // table_copy.wast:1298 |
| assert_trap(() => call($15, "check_t1", [26])); |
| |
| // table_copy.wast:1299 |
| assert_trap(() => call($15, "check_t1", [27])); |
| |
| // table_copy.wast:1300 |
| assert_trap(() => call($15, "check_t1", [28])); |
| |
| // table_copy.wast:1301 |
| assert_trap(() => call($15, "check_t1", [29])); |
| |
| // table_copy.wast:1303 |
| let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1333 |
| run(() => call($16, "test", [])); |
| |
| // table_copy.wast:1334 |
| assert_trap(() => call($16, "check_t0", [0])); |
| |
| // table_copy.wast:1335 |
| assert_trap(() => call($16, "check_t0", [1])); |
| |
| // table_copy.wast:1336 |
| assert_return(() => call($16, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1337 |
| assert_return(() => call($16, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1338 |
| assert_return(() => call($16, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1339 |
| assert_return(() => call($16, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1340 |
| assert_trap(() => call($16, "check_t0", [6])); |
| |
| // table_copy.wast:1341 |
| assert_trap(() => call($16, "check_t0", [7])); |
| |
| // table_copy.wast:1342 |
| assert_trap(() => call($16, "check_t0", [8])); |
| |
| // table_copy.wast:1343 |
| assert_trap(() => call($16, "check_t0", [9])); |
| |
| // table_copy.wast:1344 |
| assert_trap(() => call($16, "check_t0", [10])); |
| |
| // table_copy.wast:1345 |
| assert_trap(() => call($16, "check_t0", [11])); |
| |
| // table_copy.wast:1346 |
| assert_return(() => call($16, "check_t0", [12]), 7); |
| |
| // table_copy.wast:1347 |
| assert_return(() => call($16, "check_t0", [13]), 5); |
| |
| // table_copy.wast:1348 |
| assert_return(() => call($16, "check_t0", [14]), 2); |
| |
| // table_copy.wast:1349 |
| assert_return(() => call($16, "check_t0", [15]), 3); |
| |
| // table_copy.wast:1350 |
| assert_return(() => call($16, "check_t0", [16]), 6); |
| |
| // table_copy.wast:1351 |
| assert_trap(() => call($16, "check_t0", [17])); |
| |
| // table_copy.wast:1352 |
| assert_trap(() => call($16, "check_t0", [18])); |
| |
| // table_copy.wast:1353 |
| assert_trap(() => call($16, "check_t0", [19])); |
| |
| // table_copy.wast:1354 |
| assert_trap(() => call($16, "check_t0", [20])); |
| |
| // table_copy.wast:1355 |
| assert_trap(() => call($16, "check_t0", [21])); |
| |
| // table_copy.wast:1356 |
| assert_trap(() => call($16, "check_t0", [22])); |
| |
| // table_copy.wast:1357 |
| assert_trap(() => call($16, "check_t0", [23])); |
| |
| // table_copy.wast:1358 |
| assert_trap(() => call($16, "check_t0", [24])); |
| |
| // table_copy.wast:1359 |
| assert_trap(() => call($16, "check_t0", [25])); |
| |
| // table_copy.wast:1360 |
| assert_return(() => call($16, "check_t0", [26]), 3); |
| |
| // table_copy.wast:1361 |
| assert_return(() => call($16, "check_t0", [27]), 1); |
| |
| // table_copy.wast:1362 |
| assert_trap(() => call($16, "check_t0", [28])); |
| |
| // table_copy.wast:1363 |
| assert_trap(() => call($16, "check_t0", [29])); |
| |
| // table_copy.wast:1364 |
| assert_trap(() => call($16, "check_t1", [0])); |
| |
| // table_copy.wast:1365 |
| assert_trap(() => call($16, "check_t1", [1])); |
| |
| // table_copy.wast:1366 |
| assert_trap(() => call($16, "check_t1", [2])); |
| |
| // table_copy.wast:1367 |
| assert_return(() => call($16, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1368 |
| assert_return(() => call($16, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1369 |
| assert_return(() => call($16, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1370 |
| assert_return(() => call($16, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1371 |
| assert_trap(() => call($16, "check_t1", [7])); |
| |
| // table_copy.wast:1372 |
| assert_trap(() => call($16, "check_t1", [8])); |
| |
| // table_copy.wast:1373 |
| assert_trap(() => call($16, "check_t1", [9])); |
| |
| // table_copy.wast:1374 |
| assert_trap(() => call($16, "check_t1", [10])); |
| |
| // table_copy.wast:1375 |
| assert_return(() => call($16, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1376 |
| assert_return(() => call($16, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1377 |
| assert_return(() => call($16, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1378 |
| assert_return(() => call($16, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1379 |
| assert_return(() => call($16, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1380 |
| assert_trap(() => call($16, "check_t1", [16])); |
| |
| // table_copy.wast:1381 |
| assert_trap(() => call($16, "check_t1", [17])); |
| |
| // table_copy.wast:1382 |
| assert_trap(() => call($16, "check_t1", [18])); |
| |
| // table_copy.wast:1383 |
| assert_trap(() => call($16, "check_t1", [19])); |
| |
| // table_copy.wast:1384 |
| assert_trap(() => call($16, "check_t1", [20])); |
| |
| // table_copy.wast:1385 |
| assert_trap(() => call($16, "check_t1", [21])); |
| |
| // table_copy.wast:1386 |
| assert_trap(() => call($16, "check_t1", [22])); |
| |
| // table_copy.wast:1387 |
| assert_trap(() => call($16, "check_t1", [23])); |
| |
| // table_copy.wast:1388 |
| assert_trap(() => call($16, "check_t1", [24])); |
| |
| // table_copy.wast:1389 |
| assert_trap(() => call($16, "check_t1", [25])); |
| |
| // table_copy.wast:1390 |
| assert_trap(() => call($16, "check_t1", [26])); |
| |
| // table_copy.wast:1391 |
| assert_trap(() => call($16, "check_t1", [27])); |
| |
| // table_copy.wast:1392 |
| assert_trap(() => call($16, "check_t1", [28])); |
| |
| // table_copy.wast:1393 |
| assert_trap(() => call($16, "check_t1", [29])); |
| |
| // table_copy.wast:1395 |
| let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1425 |
| run(() => call($17, "test", [])); |
| |
| // table_copy.wast:1426 |
| assert_trap(() => call($17, "check_t0", [0])); |
| |
| // table_copy.wast:1427 |
| assert_trap(() => call($17, "check_t0", [1])); |
| |
| // table_copy.wast:1428 |
| assert_return(() => call($17, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1429 |
| assert_return(() => call($17, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1430 |
| assert_return(() => call($17, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1431 |
| assert_return(() => call($17, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1432 |
| assert_trap(() => call($17, "check_t0", [6])); |
| |
| // table_copy.wast:1433 |
| assert_trap(() => call($17, "check_t0", [7])); |
| |
| // table_copy.wast:1434 |
| assert_trap(() => call($17, "check_t0", [8])); |
| |
| // table_copy.wast:1435 |
| assert_trap(() => call($17, "check_t0", [9])); |
| |
| // table_copy.wast:1436 |
| assert_return(() => call($17, "check_t0", [10]), 7); |
| |
| // table_copy.wast:1437 |
| assert_return(() => call($17, "check_t0", [11]), 5); |
| |
| // table_copy.wast:1438 |
| assert_return(() => call($17, "check_t0", [12]), 2); |
| |
| // table_copy.wast:1439 |
| assert_return(() => call($17, "check_t0", [13]), 3); |
| |
| // table_copy.wast:1440 |
| assert_return(() => call($17, "check_t0", [14]), 6); |
| |
| // table_copy.wast:1441 |
| assert_trap(() => call($17, "check_t0", [15])); |
| |
| // table_copy.wast:1442 |
| assert_trap(() => call($17, "check_t0", [16])); |
| |
| // table_copy.wast:1443 |
| assert_trap(() => call($17, "check_t0", [17])); |
| |
| // table_copy.wast:1444 |
| assert_trap(() => call($17, "check_t0", [18])); |
| |
| // table_copy.wast:1445 |
| assert_trap(() => call($17, "check_t0", [19])); |
| |
| // table_copy.wast:1446 |
| assert_trap(() => call($17, "check_t0", [20])); |
| |
| // table_copy.wast:1447 |
| assert_trap(() => call($17, "check_t0", [21])); |
| |
| // table_copy.wast:1448 |
| assert_trap(() => call($17, "check_t0", [22])); |
| |
| // table_copy.wast:1449 |
| assert_trap(() => call($17, "check_t0", [23])); |
| |
| // table_copy.wast:1450 |
| assert_trap(() => call($17, "check_t0", [24])); |
| |
| // table_copy.wast:1451 |
| assert_trap(() => call($17, "check_t0", [25])); |
| |
| // table_copy.wast:1452 |
| assert_trap(() => call($17, "check_t0", [26])); |
| |
| // table_copy.wast:1453 |
| assert_trap(() => call($17, "check_t0", [27])); |
| |
| // table_copy.wast:1454 |
| assert_trap(() => call($17, "check_t0", [28])); |
| |
| // table_copy.wast:1455 |
| assert_trap(() => call($17, "check_t0", [29])); |
| |
| // table_copy.wast:1456 |
| assert_trap(() => call($17, "check_t1", [0])); |
| |
| // table_copy.wast:1457 |
| assert_trap(() => call($17, "check_t1", [1])); |
| |
| // table_copy.wast:1458 |
| assert_trap(() => call($17, "check_t1", [2])); |
| |
| // table_copy.wast:1459 |
| assert_return(() => call($17, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1460 |
| assert_return(() => call($17, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1461 |
| assert_return(() => call($17, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1462 |
| assert_return(() => call($17, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1463 |
| assert_trap(() => call($17, "check_t1", [7])); |
| |
| // table_copy.wast:1464 |
| assert_trap(() => call($17, "check_t1", [8])); |
| |
| // table_copy.wast:1465 |
| assert_trap(() => call($17, "check_t1", [9])); |
| |
| // table_copy.wast:1466 |
| assert_trap(() => call($17, "check_t1", [10])); |
| |
| // table_copy.wast:1467 |
| assert_return(() => call($17, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1468 |
| assert_return(() => call($17, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1469 |
| assert_return(() => call($17, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1470 |
| assert_return(() => call($17, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1471 |
| assert_return(() => call($17, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1472 |
| assert_trap(() => call($17, "check_t1", [16])); |
| |
| // table_copy.wast:1473 |
| assert_trap(() => call($17, "check_t1", [17])); |
| |
| // table_copy.wast:1474 |
| assert_trap(() => call($17, "check_t1", [18])); |
| |
| // table_copy.wast:1475 |
| assert_trap(() => call($17, "check_t1", [19])); |
| |
| // table_copy.wast:1476 |
| assert_trap(() => call($17, "check_t1", [20])); |
| |
| // table_copy.wast:1477 |
| assert_trap(() => call($17, "check_t1", [21])); |
| |
| // table_copy.wast:1478 |
| assert_trap(() => call($17, "check_t1", [22])); |
| |
| // table_copy.wast:1479 |
| assert_trap(() => call($17, "check_t1", [23])); |
| |
| // table_copy.wast:1480 |
| assert_trap(() => call($17, "check_t1", [24])); |
| |
| // table_copy.wast:1481 |
| assert_trap(() => call($17, "check_t1", [25])); |
| |
| // table_copy.wast:1482 |
| assert_trap(() => call($17, "check_t1", [26])); |
| |
| // table_copy.wast:1483 |
| assert_trap(() => call($17, "check_t1", [27])); |
| |
| // table_copy.wast:1484 |
| assert_trap(() => call($17, "check_t1", [28])); |
| |
| // table_copy.wast:1485 |
| assert_trap(() => call($17, "check_t1", [29])); |
| |
| // table_copy.wast:1487 |
| let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1517 |
| run(() => call($18, "test", [])); |
| |
| // table_copy.wast:1518 |
| assert_trap(() => call($18, "check_t0", [0])); |
| |
| // table_copy.wast:1519 |
| assert_trap(() => call($18, "check_t0", [1])); |
| |
| // table_copy.wast:1520 |
| assert_return(() => call($18, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1521 |
| assert_return(() => call($18, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1522 |
| assert_return(() => call($18, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1523 |
| assert_return(() => call($18, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1524 |
| assert_trap(() => call($18, "check_t0", [6])); |
| |
| // table_copy.wast:1525 |
| assert_trap(() => call($18, "check_t0", [7])); |
| |
| // table_copy.wast:1526 |
| assert_trap(() => call($18, "check_t0", [8])); |
| |
| // table_copy.wast:1527 |
| assert_trap(() => call($18, "check_t0", [9])); |
| |
| // table_copy.wast:1528 |
| assert_trap(() => call($18, "check_t0", [10])); |
| |
| // table_copy.wast:1529 |
| assert_trap(() => call($18, "check_t0", [11])); |
| |
| // table_copy.wast:1530 |
| assert_trap(() => call($18, "check_t0", [12])); |
| |
| // table_copy.wast:1531 |
| assert_trap(() => call($18, "check_t0", [13])); |
| |
| // table_copy.wast:1532 |
| assert_return(() => call($18, "check_t0", [14]), 7); |
| |
| // table_copy.wast:1533 |
| assert_return(() => call($18, "check_t0", [15]), 5); |
| |
| // table_copy.wast:1534 |
| assert_return(() => call($18, "check_t0", [16]), 2); |
| |
| // table_copy.wast:1535 |
| assert_return(() => call($18, "check_t0", [17]), 3); |
| |
| // table_copy.wast:1536 |
| assert_return(() => call($18, "check_t0", [18]), 6); |
| |
| // table_copy.wast:1537 |
| assert_trap(() => call($18, "check_t0", [19])); |
| |
| // table_copy.wast:1538 |
| assert_trap(() => call($18, "check_t0", [20])); |
| |
| // table_copy.wast:1539 |
| assert_trap(() => call($18, "check_t0", [21])); |
| |
| // table_copy.wast:1540 |
| assert_trap(() => call($18, "check_t0", [22])); |
| |
| // table_copy.wast:1541 |
| assert_trap(() => call($18, "check_t0", [23])); |
| |
| // table_copy.wast:1542 |
| assert_trap(() => call($18, "check_t0", [24])); |
| |
| // table_copy.wast:1543 |
| assert_trap(() => call($18, "check_t0", [25])); |
| |
| // table_copy.wast:1544 |
| assert_trap(() => call($18, "check_t0", [26])); |
| |
| // table_copy.wast:1545 |
| assert_trap(() => call($18, "check_t0", [27])); |
| |
| // table_copy.wast:1546 |
| assert_trap(() => call($18, "check_t0", [28])); |
| |
| // table_copy.wast:1547 |
| assert_trap(() => call($18, "check_t0", [29])); |
| |
| // table_copy.wast:1548 |
| assert_trap(() => call($18, "check_t1", [0])); |
| |
| // table_copy.wast:1549 |
| assert_trap(() => call($18, "check_t1", [1])); |
| |
| // table_copy.wast:1550 |
| assert_trap(() => call($18, "check_t1", [2])); |
| |
| // table_copy.wast:1551 |
| assert_return(() => call($18, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1552 |
| assert_return(() => call($18, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1553 |
| assert_return(() => call($18, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1554 |
| assert_return(() => call($18, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1555 |
| assert_trap(() => call($18, "check_t1", [7])); |
| |
| // table_copy.wast:1556 |
| assert_trap(() => call($18, "check_t1", [8])); |
| |
| // table_copy.wast:1557 |
| assert_trap(() => call($18, "check_t1", [9])); |
| |
| // table_copy.wast:1558 |
| assert_trap(() => call($18, "check_t1", [10])); |
| |
| // table_copy.wast:1559 |
| assert_return(() => call($18, "check_t1", [11]), 6); |
| |
| // table_copy.wast:1560 |
| assert_return(() => call($18, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1561 |
| assert_return(() => call($18, "check_t1", [13]), 2); |
| |
| // table_copy.wast:1562 |
| assert_return(() => call($18, "check_t1", [14]), 5); |
| |
| // table_copy.wast:1563 |
| assert_return(() => call($18, "check_t1", [15]), 7); |
| |
| // table_copy.wast:1564 |
| assert_trap(() => call($18, "check_t1", [16])); |
| |
| // table_copy.wast:1565 |
| assert_trap(() => call($18, "check_t1", [17])); |
| |
| // table_copy.wast:1566 |
| assert_trap(() => call($18, "check_t1", [18])); |
| |
| // table_copy.wast:1567 |
| assert_trap(() => call($18, "check_t1", [19])); |
| |
| // table_copy.wast:1568 |
| assert_trap(() => call($18, "check_t1", [20])); |
| |
| // table_copy.wast:1569 |
| assert_trap(() => call($18, "check_t1", [21])); |
| |
| // table_copy.wast:1570 |
| assert_trap(() => call($18, "check_t1", [22])); |
| |
| // table_copy.wast:1571 |
| assert_trap(() => call($18, "check_t1", [23])); |
| |
| // table_copy.wast:1572 |
| assert_trap(() => call($18, "check_t1", [24])); |
| |
| // table_copy.wast:1573 |
| assert_trap(() => call($18, "check_t1", [25])); |
| |
| // table_copy.wast:1574 |
| assert_trap(() => call($18, "check_t1", [26])); |
| |
| // table_copy.wast:1575 |
| assert_trap(() => call($18, "check_t1", [27])); |
| |
| // table_copy.wast:1576 |
| assert_trap(() => call($18, "check_t1", [28])); |
| |
| // table_copy.wast:1577 |
| assert_trap(() => call($18, "check_t1", [29])); |
| |
| // table_copy.wast:1579 |
| let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b"); |
| |
| // table_copy.wast:1609 |
| run(() => call($19, "test", [])); |
| |
| // table_copy.wast:1610 |
| assert_trap(() => call($19, "check_t0", [0])); |
| |
| // table_copy.wast:1611 |
| assert_trap(() => call($19, "check_t0", [1])); |
| |
| // table_copy.wast:1612 |
| assert_return(() => call($19, "check_t0", [2]), 3); |
| |
| // table_copy.wast:1613 |
| assert_return(() => call($19, "check_t0", [3]), 1); |
| |
| // table_copy.wast:1614 |
| assert_return(() => call($19, "check_t0", [4]), 4); |
| |
| // table_copy.wast:1615 |
| assert_return(() => call($19, "check_t0", [5]), 1); |
| |
| // table_copy.wast:1616 |
| assert_trap(() => call($19, "check_t0", [6])); |
| |
| // table_copy.wast:1617 |
| assert_trap(() => call($19, "check_t0", [7])); |
| |
| // table_copy.wast:1618 |
| assert_trap(() => call($19, "check_t0", [8])); |
| |
| // table_copy.wast:1619 |
| assert_trap(() => call($19, "check_t0", [9])); |
| |
| // table_copy.wast:1620 |
| assert_trap(() => call($19, "check_t0", [10])); |
| |
| // table_copy.wast:1621 |
| assert_trap(() => call($19, "check_t0", [11])); |
| |
| // table_copy.wast:1622 |
| assert_return(() => call($19, "check_t0", [12]), 7); |
| |
| // table_copy.wast:1623 |
| assert_return(() => call($19, "check_t0", [13]), 5); |
| |
| // table_copy.wast:1624 |
| assert_return(() => call($19, "check_t0", [14]), 2); |
| |
| // table_copy.wast:1625 |
| assert_return(() => call($19, "check_t0", [15]), 3); |
| |
| // table_copy.wast:1626 |
| assert_return(() => call($19, "check_t0", [16]), 6); |
| |
| // table_copy.wast:1627 |
| assert_trap(() => call($19, "check_t0", [17])); |
| |
| // table_copy.wast:1628 |
| assert_trap(() => call($19, "check_t0", [18])); |
| |
| // table_copy.wast:1629 |
| assert_trap(() => call($19, "check_t0", [19])); |
| |
| // table_copy.wast:1630 |
| assert_trap(() => call($19, "check_t0", [20])); |
| |
| // table_copy.wast:1631 |
| assert_trap(() => call($19, "check_t0", [21])); |
| |
| // table_copy.wast:1632 |
| assert_trap(() => call($19, "check_t0", [22])); |
| |
| // table_copy.wast:1633 |
| assert_trap(() => call($19, "check_t0", [23])); |
| |
| // table_copy.wast:1634 |
| assert_trap(() => call($19, "check_t0", [24])); |
| |
| // table_copy.wast:1635 |
| assert_trap(() => call($19, "check_t0", [25])); |
| |
| // table_copy.wast:1636 |
| assert_trap(() => call($19, "check_t0", [26])); |
| |
| // table_copy.wast:1637 |
| assert_trap(() => call($19, "check_t0", [27])); |
| |
| // table_copy.wast:1638 |
| assert_trap(() => call($19, "check_t0", [28])); |
| |
| // table_copy.wast:1639 |
| assert_trap(() => call($19, "check_t0", [29])); |
| |
| // table_copy.wast:1640 |
| assert_trap(() => call($19, "check_t1", [0])); |
| |
| // table_copy.wast:1641 |
| assert_trap(() => call($19, "check_t1", [1])); |
| |
| // table_copy.wast:1642 |
| assert_trap(() => call($19, "check_t1", [2])); |
| |
| // table_copy.wast:1643 |
| assert_return(() => call($19, "check_t1", [3]), 1); |
| |
| // table_copy.wast:1644 |
| assert_return(() => call($19, "check_t1", [4]), 3); |
| |
| // table_copy.wast:1645 |
| assert_return(() => call($19, "check_t1", [5]), 1); |
| |
| // table_copy.wast:1646 |
| assert_return(() => call($19, "check_t1", [6]), 4); |
| |
| // table_copy.wast:1647 |
| assert_trap(() => call($19, "check_t1", [7])); |
| |
| // table_copy.wast:1648 |
| assert_trap(() => call($19, "check_t1", [8])); |
| |
| // table_copy.wast:1649 |
| assert_trap(() => call($19, "check_t1", [9])); |
| |
| // table_copy.wast:1650 |
| assert_trap(() => call($19, "check_t1", [10])); |
| |
| // table_copy.wast:1651 |
| assert_trap(() => call($19, "check_t1", [11])); |
| |
| // table_copy.wast:1652 |
| assert_return(() => call($19, "check_t1", [12]), 3); |
| |
| // table_copy.wast:1653 |
| assert_return(() => call($19, "check_t1", [13]), 1); |
| |
| // table_copy.wast:1654 |
| assert_return(() => call($19, "check_t1", [14]), 4); |
| |
| // table_copy.wast:1655 |
| assert_return(() => call($19, "check_t1", [15]), 1); |
| |
| // table_copy.wast:1656 |
| assert_trap(() => call($19, "check_t1", [16])); |
| |
| // table_copy.wast:1657 |
| assert_trap(() => call($19, "check_t1", [17])); |
| |
| // table_copy.wast:1658 |
| assert_trap(() => call($19, "check_t1", [18])); |
| |
| // table_copy.wast:1659 |
| assert_trap(() => call($19, "check_t1", [19])); |
| |
| // table_copy.wast:1660 |
| assert_trap(() => call($19, "check_t1", [20])); |
| |
| // table_copy.wast:1661 |
| assert_trap(() => call($19, "check_t1", [21])); |
| |
| // table_copy.wast:1662 |
| assert_return(() => call($19, "check_t1", [22]), 7); |
| |
| // table_copy.wast:1663 |
| assert_return(() => call($19, "check_t1", [23]), 5); |
| |
| // table_copy.wast:1664 |
| assert_return(() => call($19, "check_t1", [24]), 2); |
| |
| // table_copy.wast:1665 |
| assert_return(() => call($19, "check_t1", [25]), 3); |
| |
| // table_copy.wast:1666 |
| assert_return(() => call($19, "check_t1", [26]), 6); |
| |
| // table_copy.wast:1667 |
| assert_trap(() => call($19, "check_t1", [27])); |
| |
| // table_copy.wast:1668 |
| assert_trap(() => call($19, "check_t1", [28])); |
| |
| // table_copy.wast:1669 |
| assert_trap(() => call($19, "check_t1", [29])); |
| |
| // table_copy.wast:1671 |
| let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1694 |
| assert_trap(() => call($20, "test", [])); |
| |
| // table_copy.wast:1696 |
| let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1719 |
| assert_trap(() => call($21, "test", [])); |
| |
| // table_copy.wast:1721 |
| let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1744 |
| assert_trap(() => call($22, "test", [])); |
| |
| // table_copy.wast:1746 |
| let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1769 |
| assert_trap(() => call($23, "test", [])); |
| |
| // table_copy.wast:1771 |
| let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1794 |
| run(() => call($24, "test", [])); |
| |
| // table_copy.wast:1796 |
| let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1819 |
| run(() => call($25, "test", [])); |
| |
| // table_copy.wast:1821 |
| let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1844 |
| assert_trap(() => call($26, "test", [])); |
| |
| // table_copy.wast:1846 |
| let $27 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1869 |
| run(() => call($27, "test", [])); |
| |
| // table_copy.wast:1871 |
| let $28 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1894 |
| assert_trap(() => call($28, "test", [])); |
| |
| // table_copy.wast:1896 |
| let $29 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1919 |
| run(() => call($29, "test", [])); |
| |
| // table_copy.wast:1921 |
| let $30 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:1944 |
| assert_trap(() => call($30, "test", [])); |
| |
| // table_copy.wast:1946 |
| let $31 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:1969 |
| assert_trap(() => call($31, "test", [])); |
| |
| // table_copy.wast:1971 |
| let $32 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:1994 |
| assert_trap(() => call($32, "test", [])); |
| |
| // table_copy.wast:1996 |
| let $33 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2019 |
| assert_trap(() => call($33, "test", [])); |
| |
| // table_copy.wast:2021 |
| let $34 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2044 |
| assert_trap(() => call($34, "test", [])); |
| |
| // table_copy.wast:2046 |
| let $35 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2069 |
| run(() => call($35, "test", [])); |
| |
| // table_copy.wast:2071 |
| let $36 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2094 |
| run(() => call($36, "test", [])); |
| |
| // table_copy.wast:2096 |
| let $37 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2119 |
| assert_trap(() => call($37, "test", [])); |
| |
| // table_copy.wast:2121 |
| let $38 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2144 |
| run(() => call($38, "test", [])); |
| |
| // table_copy.wast:2146 |
| let $39 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2169 |
| assert_trap(() => call($39, "test", [])); |
| |
| // table_copy.wast:2171 |
| let $40 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2194 |
| run(() => call($40, "test", [])); |
| |
| // table_copy.wast:2196 |
| let $41 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b"); |
| |
| // table_copy.wast:2219 |
| assert_trap(() => call($41, "test", [])); |
| |
| // table_copy.wast:2221 |
| let $42 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2247 |
| assert_trap(() => call($42, "run", [24, 0, 16])); |
| |
| // table_copy.wast:2249 |
| assert_return(() => call($42, "test", [0]), 0); |
| |
| // table_copy.wast:2250 |
| assert_return(() => call($42, "test", [1]), 1); |
| |
| // table_copy.wast:2251 |
| assert_return(() => call($42, "test", [2]), 2); |
| |
| // table_copy.wast:2252 |
| assert_return(() => call($42, "test", [3]), 3); |
| |
| // table_copy.wast:2253 |
| assert_return(() => call($42, "test", [4]), 4); |
| |
| // table_copy.wast:2254 |
| assert_return(() => call($42, "test", [5]), 5); |
| |
| // table_copy.wast:2255 |
| assert_return(() => call($42, "test", [6]), 6); |
| |
| // table_copy.wast:2256 |
| assert_return(() => call($42, "test", [7]), 7); |
| |
| // table_copy.wast:2257 |
| assert_trap(() => call($42, "test", [8])); |
| |
| // table_copy.wast:2258 |
| assert_trap(() => call($42, "test", [9])); |
| |
| // table_copy.wast:2259 |
| assert_trap(() => call($42, "test", [10])); |
| |
| // table_copy.wast:2260 |
| assert_trap(() => call($42, "test", [11])); |
| |
| // table_copy.wast:2261 |
| assert_trap(() => call($42, "test", [12])); |
| |
| // table_copy.wast:2262 |
| assert_trap(() => call($42, "test", [13])); |
| |
| // table_copy.wast:2263 |
| assert_trap(() => call($42, "test", [14])); |
| |
| // table_copy.wast:2264 |
| assert_trap(() => call($42, "test", [15])); |
| |
| // table_copy.wast:2265 |
| assert_trap(() => call($42, "test", [16])); |
| |
| // table_copy.wast:2266 |
| assert_trap(() => call($42, "test", [17])); |
| |
| // table_copy.wast:2267 |
| assert_trap(() => call($42, "test", [18])); |
| |
| // table_copy.wast:2268 |
| assert_trap(() => call($42, "test", [19])); |
| |
| // table_copy.wast:2269 |
| assert_trap(() => call($42, "test", [20])); |
| |
| // table_copy.wast:2270 |
| assert_trap(() => call($42, "test", [21])); |
| |
| // table_copy.wast:2271 |
| assert_trap(() => call($42, "test", [22])); |
| |
| // table_copy.wast:2272 |
| assert_trap(() => call($42, "test", [23])); |
| |
| // table_copy.wast:2273 |
| assert_trap(() => call($42, "test", [24])); |
| |
| // table_copy.wast:2274 |
| assert_trap(() => call($42, "test", [25])); |
| |
| // table_copy.wast:2275 |
| assert_trap(() => call($42, "test", [26])); |
| |
| // table_copy.wast:2276 |
| assert_trap(() => call($42, "test", [27])); |
| |
| // table_copy.wast:2277 |
| assert_trap(() => call($42, "test", [28])); |
| |
| // table_copy.wast:2278 |
| assert_trap(() => call($42, "test", [29])); |
| |
| // table_copy.wast:2279 |
| assert_trap(() => call($42, "test", [30])); |
| |
| // table_copy.wast:2280 |
| assert_trap(() => call($42, "test", [31])); |
| |
| // table_copy.wast:2282 |
| let $43 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2308 |
| assert_trap(() => call($43, "run", [23, 0, 15])); |
| |
| // table_copy.wast:2310 |
| assert_return(() => call($43, "test", [0]), 0); |
| |
| // table_copy.wast:2311 |
| assert_return(() => call($43, "test", [1]), 1); |
| |
| // table_copy.wast:2312 |
| assert_return(() => call($43, "test", [2]), 2); |
| |
| // table_copy.wast:2313 |
| assert_return(() => call($43, "test", [3]), 3); |
| |
| // table_copy.wast:2314 |
| assert_return(() => call($43, "test", [4]), 4); |
| |
| // table_copy.wast:2315 |
| assert_return(() => call($43, "test", [5]), 5); |
| |
| // table_copy.wast:2316 |
| assert_return(() => call($43, "test", [6]), 6); |
| |
| // table_copy.wast:2317 |
| assert_return(() => call($43, "test", [7]), 7); |
| |
| // table_copy.wast:2318 |
| assert_return(() => call($43, "test", [8]), 8); |
| |
| // table_copy.wast:2319 |
| assert_trap(() => call($43, "test", [9])); |
| |
| // table_copy.wast:2320 |
| assert_trap(() => call($43, "test", [10])); |
| |
| // table_copy.wast:2321 |
| assert_trap(() => call($43, "test", [11])); |
| |
| // table_copy.wast:2322 |
| assert_trap(() => call($43, "test", [12])); |
| |
| // table_copy.wast:2323 |
| assert_trap(() => call($43, "test", [13])); |
| |
| // table_copy.wast:2324 |
| assert_trap(() => call($43, "test", [14])); |
| |
| // table_copy.wast:2325 |
| assert_trap(() => call($43, "test", [15])); |
| |
| // table_copy.wast:2326 |
| assert_trap(() => call($43, "test", [16])); |
| |
| // table_copy.wast:2327 |
| assert_trap(() => call($43, "test", [17])); |
| |
| // table_copy.wast:2328 |
| assert_trap(() => call($43, "test", [18])); |
| |
| // table_copy.wast:2329 |
| assert_trap(() => call($43, "test", [19])); |
| |
| // table_copy.wast:2330 |
| assert_trap(() => call($43, "test", [20])); |
| |
| // table_copy.wast:2331 |
| assert_trap(() => call($43, "test", [21])); |
| |
| // table_copy.wast:2332 |
| assert_trap(() => call($43, "test", [22])); |
| |
| // table_copy.wast:2333 |
| assert_trap(() => call($43, "test", [23])); |
| |
| // table_copy.wast:2334 |
| assert_trap(() => call($43, "test", [24])); |
| |
| // table_copy.wast:2335 |
| assert_trap(() => call($43, "test", [25])); |
| |
| // table_copy.wast:2336 |
| assert_trap(() => call($43, "test", [26])); |
| |
| // table_copy.wast:2337 |
| assert_trap(() => call($43, "test", [27])); |
| |
| // table_copy.wast:2338 |
| assert_trap(() => call($43, "test", [28])); |
| |
| // table_copy.wast:2339 |
| assert_trap(() => call($43, "test", [29])); |
| |
| // table_copy.wast:2340 |
| assert_trap(() => call($43, "test", [30])); |
| |
| // table_copy.wast:2341 |
| assert_trap(() => call($43, "test", [31])); |
| |
| // table_copy.wast:2343 |
| let $44 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2369 |
| assert_trap(() => call($44, "run", [0, 24, 16])); |
| |
| // table_copy.wast:2371 |
| assert_trap(() => call($44, "test", [0])); |
| |
| // table_copy.wast:2372 |
| assert_trap(() => call($44, "test", [1])); |
| |
| // table_copy.wast:2373 |
| assert_trap(() => call($44, "test", [2])); |
| |
| // table_copy.wast:2374 |
| assert_trap(() => call($44, "test", [3])); |
| |
| // table_copy.wast:2375 |
| assert_trap(() => call($44, "test", [4])); |
| |
| // table_copy.wast:2376 |
| assert_trap(() => call($44, "test", [5])); |
| |
| // table_copy.wast:2377 |
| assert_trap(() => call($44, "test", [6])); |
| |
| // table_copy.wast:2378 |
| assert_trap(() => call($44, "test", [7])); |
| |
| // table_copy.wast:2379 |
| assert_trap(() => call($44, "test", [8])); |
| |
| // table_copy.wast:2380 |
| assert_trap(() => call($44, "test", [9])); |
| |
| // table_copy.wast:2381 |
| assert_trap(() => call($44, "test", [10])); |
| |
| // table_copy.wast:2382 |
| assert_trap(() => call($44, "test", [11])); |
| |
| // table_copy.wast:2383 |
| assert_trap(() => call($44, "test", [12])); |
| |
| // table_copy.wast:2384 |
| assert_trap(() => call($44, "test", [13])); |
| |
| // table_copy.wast:2385 |
| assert_trap(() => call($44, "test", [14])); |
| |
| // table_copy.wast:2386 |
| assert_trap(() => call($44, "test", [15])); |
| |
| // table_copy.wast:2387 |
| assert_trap(() => call($44, "test", [16])); |
| |
| // table_copy.wast:2388 |
| assert_trap(() => call($44, "test", [17])); |
| |
| // table_copy.wast:2389 |
| assert_trap(() => call($44, "test", [18])); |
| |
| // table_copy.wast:2390 |
| assert_trap(() => call($44, "test", [19])); |
| |
| // table_copy.wast:2391 |
| assert_trap(() => call($44, "test", [20])); |
| |
| // table_copy.wast:2392 |
| assert_trap(() => call($44, "test", [21])); |
| |
| // table_copy.wast:2393 |
| assert_trap(() => call($44, "test", [22])); |
| |
| // table_copy.wast:2394 |
| assert_trap(() => call($44, "test", [23])); |
| |
| // table_copy.wast:2395 |
| assert_return(() => call($44, "test", [24]), 0); |
| |
| // table_copy.wast:2396 |
| assert_return(() => call($44, "test", [25]), 1); |
| |
| // table_copy.wast:2397 |
| assert_return(() => call($44, "test", [26]), 2); |
| |
| // table_copy.wast:2398 |
| assert_return(() => call($44, "test", [27]), 3); |
| |
| // table_copy.wast:2399 |
| assert_return(() => call($44, "test", [28]), 4); |
| |
| // table_copy.wast:2400 |
| assert_return(() => call($44, "test", [29]), 5); |
| |
| // table_copy.wast:2401 |
| assert_return(() => call($44, "test", [30]), 6); |
| |
| // table_copy.wast:2402 |
| assert_return(() => call($44, "test", [31]), 7); |
| |
| // table_copy.wast:2404 |
| let $45 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x17\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2430 |
| assert_trap(() => call($45, "run", [0, 23, 15])); |
| |
| // table_copy.wast:2432 |
| assert_trap(() => call($45, "test", [0])); |
| |
| // table_copy.wast:2433 |
| assert_trap(() => call($45, "test", [1])); |
| |
| // table_copy.wast:2434 |
| assert_trap(() => call($45, "test", [2])); |
| |
| // table_copy.wast:2435 |
| assert_trap(() => call($45, "test", [3])); |
| |
| // table_copy.wast:2436 |
| assert_trap(() => call($45, "test", [4])); |
| |
| // table_copy.wast:2437 |
| assert_trap(() => call($45, "test", [5])); |
| |
| // table_copy.wast:2438 |
| assert_trap(() => call($45, "test", [6])); |
| |
| // table_copy.wast:2439 |
| assert_trap(() => call($45, "test", [7])); |
| |
| // table_copy.wast:2440 |
| assert_trap(() => call($45, "test", [8])); |
| |
| // table_copy.wast:2441 |
| assert_trap(() => call($45, "test", [9])); |
| |
| // table_copy.wast:2442 |
| assert_trap(() => call($45, "test", [10])); |
| |
| // table_copy.wast:2443 |
| assert_trap(() => call($45, "test", [11])); |
| |
| // table_copy.wast:2444 |
| assert_trap(() => call($45, "test", [12])); |
| |
| // table_copy.wast:2445 |
| assert_trap(() => call($45, "test", [13])); |
| |
| // table_copy.wast:2446 |
| assert_trap(() => call($45, "test", [14])); |
| |
| // table_copy.wast:2447 |
| assert_trap(() => call($45, "test", [15])); |
| |
| // table_copy.wast:2448 |
| assert_trap(() => call($45, "test", [16])); |
| |
| // table_copy.wast:2449 |
| assert_trap(() => call($45, "test", [17])); |
| |
| // table_copy.wast:2450 |
| assert_trap(() => call($45, "test", [18])); |
| |
| // table_copy.wast:2451 |
| assert_trap(() => call($45, "test", [19])); |
| |
| // table_copy.wast:2452 |
| assert_trap(() => call($45, "test", [20])); |
| |
| // table_copy.wast:2453 |
| assert_trap(() => call($45, "test", [21])); |
| |
| // table_copy.wast:2454 |
| assert_trap(() => call($45, "test", [22])); |
| |
| // table_copy.wast:2455 |
| assert_return(() => call($45, "test", [23]), 0); |
| |
| // table_copy.wast:2456 |
| assert_return(() => call($45, "test", [24]), 1); |
| |
| // table_copy.wast:2457 |
| assert_return(() => call($45, "test", [25]), 2); |
| |
| // table_copy.wast:2458 |
| assert_return(() => call($45, "test", [26]), 3); |
| |
| // table_copy.wast:2459 |
| assert_return(() => call($45, "test", [27]), 4); |
| |
| // table_copy.wast:2460 |
| assert_return(() => call($45, "test", [28]), 5); |
| |
| // table_copy.wast:2461 |
| assert_return(() => call($45, "test", [29]), 6); |
| |
| // table_copy.wast:2462 |
| assert_return(() => call($45, "test", [30]), 7); |
| |
| // table_copy.wast:2463 |
| assert_return(() => call($45, "test", [31]), 8); |
| |
| // table_copy.wast:2465 |
| let $46 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x0b\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2491 |
| assert_trap(() => call($46, "run", [24, 11, 16])); |
| |
| // table_copy.wast:2493 |
| assert_trap(() => call($46, "test", [0])); |
| |
| // table_copy.wast:2494 |
| assert_trap(() => call($46, "test", [1])); |
| |
| // table_copy.wast:2495 |
| assert_trap(() => call($46, "test", [2])); |
| |
| // table_copy.wast:2496 |
| assert_trap(() => call($46, "test", [3])); |
| |
| // table_copy.wast:2497 |
| assert_trap(() => call($46, "test", [4])); |
| |
| // table_copy.wast:2498 |
| assert_trap(() => call($46, "test", [5])); |
| |
| // table_copy.wast:2499 |
| assert_trap(() => call($46, "test", [6])); |
| |
| // table_copy.wast:2500 |
| assert_trap(() => call($46, "test", [7])); |
| |
| // table_copy.wast:2501 |
| assert_trap(() => call($46, "test", [8])); |
| |
| // table_copy.wast:2502 |
| assert_trap(() => call($46, "test", [9])); |
| |
| // table_copy.wast:2503 |
| assert_trap(() => call($46, "test", [10])); |
| |
| // table_copy.wast:2504 |
| assert_return(() => call($46, "test", [11]), 0); |
| |
| // table_copy.wast:2505 |
| assert_return(() => call($46, "test", [12]), 1); |
| |
| // table_copy.wast:2506 |
| assert_return(() => call($46, "test", [13]), 2); |
| |
| // table_copy.wast:2507 |
| assert_return(() => call($46, "test", [14]), 3); |
| |
| // table_copy.wast:2508 |
| assert_return(() => call($46, "test", [15]), 4); |
| |
| // table_copy.wast:2509 |
| assert_return(() => call($46, "test", [16]), 5); |
| |
| // table_copy.wast:2510 |
| assert_return(() => call($46, "test", [17]), 6); |
| |
| // table_copy.wast:2511 |
| assert_return(() => call($46, "test", [18]), 7); |
| |
| // table_copy.wast:2512 |
| assert_trap(() => call($46, "test", [19])); |
| |
| // table_copy.wast:2513 |
| assert_trap(() => call($46, "test", [20])); |
| |
| // table_copy.wast:2514 |
| assert_trap(() => call($46, "test", [21])); |
| |
| // table_copy.wast:2515 |
| assert_trap(() => call($46, "test", [22])); |
| |
| // table_copy.wast:2516 |
| assert_trap(() => call($46, "test", [23])); |
| |
| // table_copy.wast:2517 |
| assert_trap(() => call($46, "test", [24])); |
| |
| // table_copy.wast:2518 |
| assert_trap(() => call($46, "test", [25])); |
| |
| // table_copy.wast:2519 |
| assert_trap(() => call($46, "test", [26])); |
| |
| // table_copy.wast:2520 |
| assert_trap(() => call($46, "test", [27])); |
| |
| // table_copy.wast:2521 |
| assert_trap(() => call($46, "test", [28])); |
| |
| // table_copy.wast:2522 |
| assert_trap(() => call($46, "test", [29])); |
| |
| // table_copy.wast:2523 |
| assert_trap(() => call($46, "test", [30])); |
| |
| // table_copy.wast:2524 |
| assert_trap(() => call($46, "test", [31])); |
| |
| // table_copy.wast:2526 |
| let $47 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2552 |
| assert_trap(() => call($47, "run", [11, 24, 16])); |
| |
| // table_copy.wast:2554 |
| assert_trap(() => call($47, "test", [0])); |
| |
| // table_copy.wast:2555 |
| assert_trap(() => call($47, "test", [1])); |
| |
| // table_copy.wast:2556 |
| assert_trap(() => call($47, "test", [2])); |
| |
| // table_copy.wast:2557 |
| assert_trap(() => call($47, "test", [3])); |
| |
| // table_copy.wast:2558 |
| assert_trap(() => call($47, "test", [4])); |
| |
| // table_copy.wast:2559 |
| assert_trap(() => call($47, "test", [5])); |
| |
| // table_copy.wast:2560 |
| assert_trap(() => call($47, "test", [6])); |
| |
| // table_copy.wast:2561 |
| assert_trap(() => call($47, "test", [7])); |
| |
| // table_copy.wast:2562 |
| assert_trap(() => call($47, "test", [8])); |
| |
| // table_copy.wast:2563 |
| assert_trap(() => call($47, "test", [9])); |
| |
| // table_copy.wast:2564 |
| assert_trap(() => call($47, "test", [10])); |
| |
| // table_copy.wast:2565 |
| assert_trap(() => call($47, "test", [11])); |
| |
| // table_copy.wast:2566 |
| assert_trap(() => call($47, "test", [12])); |
| |
| // table_copy.wast:2567 |
| assert_trap(() => call($47, "test", [13])); |
| |
| // table_copy.wast:2568 |
| assert_trap(() => call($47, "test", [14])); |
| |
| // table_copy.wast:2569 |
| assert_trap(() => call($47, "test", [15])); |
| |
| // table_copy.wast:2570 |
| assert_trap(() => call($47, "test", [16])); |
| |
| // table_copy.wast:2571 |
| assert_trap(() => call($47, "test", [17])); |
| |
| // table_copy.wast:2572 |
| assert_trap(() => call($47, "test", [18])); |
| |
| // table_copy.wast:2573 |
| assert_trap(() => call($47, "test", [19])); |
| |
| // table_copy.wast:2574 |
| assert_trap(() => call($47, "test", [20])); |
| |
| // table_copy.wast:2575 |
| assert_trap(() => call($47, "test", [21])); |
| |
| // table_copy.wast:2576 |
| assert_trap(() => call($47, "test", [22])); |
| |
| // table_copy.wast:2577 |
| assert_trap(() => call($47, "test", [23])); |
| |
| // table_copy.wast:2578 |
| assert_return(() => call($47, "test", [24]), 0); |
| |
| // table_copy.wast:2579 |
| assert_return(() => call($47, "test", [25]), 1); |
| |
| // table_copy.wast:2580 |
| assert_return(() => call($47, "test", [26]), 2); |
| |
| // table_copy.wast:2581 |
| assert_return(() => call($47, "test", [27]), 3); |
| |
| // table_copy.wast:2582 |
| assert_return(() => call($47, "test", [28]), 4); |
| |
| // table_copy.wast:2583 |
| assert_return(() => call($47, "test", [29]), 5); |
| |
| // table_copy.wast:2584 |
| assert_return(() => call($47, "test", [30]), 6); |
| |
| // table_copy.wast:2585 |
| assert_return(() => call($47, "test", [31]), 7); |
| |
| // table_copy.wast:2587 |
| let $48 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2613 |
| assert_trap(() => call($48, "run", [24, 21, 16])); |
| |
| // table_copy.wast:2615 |
| assert_trap(() => call($48, "test", [0])); |
| |
| // table_copy.wast:2616 |
| assert_trap(() => call($48, "test", [1])); |
| |
| // table_copy.wast:2617 |
| assert_trap(() => call($48, "test", [2])); |
| |
| // table_copy.wast:2618 |
| assert_trap(() => call($48, "test", [3])); |
| |
| // table_copy.wast:2619 |
| assert_trap(() => call($48, "test", [4])); |
| |
| // table_copy.wast:2620 |
| assert_trap(() => call($48, "test", [5])); |
| |
| // table_copy.wast:2621 |
| assert_trap(() => call($48, "test", [6])); |
| |
| // table_copy.wast:2622 |
| assert_trap(() => call($48, "test", [7])); |
| |
| // table_copy.wast:2623 |
| assert_trap(() => call($48, "test", [8])); |
| |
| // table_copy.wast:2624 |
| assert_trap(() => call($48, "test", [9])); |
| |
| // table_copy.wast:2625 |
| assert_trap(() => call($48, "test", [10])); |
| |
| // table_copy.wast:2626 |
| assert_trap(() => call($48, "test", [11])); |
| |
| // table_copy.wast:2627 |
| assert_trap(() => call($48, "test", [12])); |
| |
| // table_copy.wast:2628 |
| assert_trap(() => call($48, "test", [13])); |
| |
| // table_copy.wast:2629 |
| assert_trap(() => call($48, "test", [14])); |
| |
| // table_copy.wast:2630 |
| assert_trap(() => call($48, "test", [15])); |
| |
| // table_copy.wast:2631 |
| assert_trap(() => call($48, "test", [16])); |
| |
| // table_copy.wast:2632 |
| assert_trap(() => call($48, "test", [17])); |
| |
| // table_copy.wast:2633 |
| assert_trap(() => call($48, "test", [18])); |
| |
| // table_copy.wast:2634 |
| assert_trap(() => call($48, "test", [19])); |
| |
| // table_copy.wast:2635 |
| assert_trap(() => call($48, "test", [20])); |
| |
| // table_copy.wast:2636 |
| assert_return(() => call($48, "test", [21]), 0); |
| |
| // table_copy.wast:2637 |
| assert_return(() => call($48, "test", [22]), 1); |
| |
| // table_copy.wast:2638 |
| assert_return(() => call($48, "test", [23]), 2); |
| |
| // table_copy.wast:2639 |
| assert_return(() => call($48, "test", [24]), 3); |
| |
| // table_copy.wast:2640 |
| assert_return(() => call($48, "test", [25]), 4); |
| |
| // table_copy.wast:2641 |
| assert_return(() => call($48, "test", [26]), 5); |
| |
| // table_copy.wast:2642 |
| assert_return(() => call($48, "test", [27]), 6); |
| |
| // table_copy.wast:2643 |
| assert_return(() => call($48, "test", [28]), 7); |
| |
| // table_copy.wast:2644 |
| assert_trap(() => call($48, "test", [29])); |
| |
| // table_copy.wast:2645 |
| assert_trap(() => call($48, "test", [30])); |
| |
| // table_copy.wast:2646 |
| assert_trap(() => call($48, "test", [31])); |
| |
| // table_copy.wast:2648 |
| let $49 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2674 |
| assert_trap(() => call($49, "run", [21, 24, 16])); |
| |
| // table_copy.wast:2676 |
| assert_trap(() => call($49, "test", [0])); |
| |
| // table_copy.wast:2677 |
| assert_trap(() => call($49, "test", [1])); |
| |
| // table_copy.wast:2678 |
| assert_trap(() => call($49, "test", [2])); |
| |
| // table_copy.wast:2679 |
| assert_trap(() => call($49, "test", [3])); |
| |
| // table_copy.wast:2680 |
| assert_trap(() => call($49, "test", [4])); |
| |
| // table_copy.wast:2681 |
| assert_trap(() => call($49, "test", [5])); |
| |
| // table_copy.wast:2682 |
| assert_trap(() => call($49, "test", [6])); |
| |
| // table_copy.wast:2683 |
| assert_trap(() => call($49, "test", [7])); |
| |
| // table_copy.wast:2684 |
| assert_trap(() => call($49, "test", [8])); |
| |
| // table_copy.wast:2685 |
| assert_trap(() => call($49, "test", [9])); |
| |
| // table_copy.wast:2686 |
| assert_trap(() => call($49, "test", [10])); |
| |
| // table_copy.wast:2687 |
| assert_trap(() => call($49, "test", [11])); |
| |
| // table_copy.wast:2688 |
| assert_trap(() => call($49, "test", [12])); |
| |
| // table_copy.wast:2689 |
| assert_trap(() => call($49, "test", [13])); |
| |
| // table_copy.wast:2690 |
| assert_trap(() => call($49, "test", [14])); |
| |
| // table_copy.wast:2691 |
| assert_trap(() => call($49, "test", [15])); |
| |
| // table_copy.wast:2692 |
| assert_trap(() => call($49, "test", [16])); |
| |
| // table_copy.wast:2693 |
| assert_trap(() => call($49, "test", [17])); |
| |
| // table_copy.wast:2694 |
| assert_trap(() => call($49, "test", [18])); |
| |
| // table_copy.wast:2695 |
| assert_trap(() => call($49, "test", [19])); |
| |
| // table_copy.wast:2696 |
| assert_trap(() => call($49, "test", [20])); |
| |
| // table_copy.wast:2697 |
| assert_trap(() => call($49, "test", [21])); |
| |
| // table_copy.wast:2698 |
| assert_trap(() => call($49, "test", [22])); |
| |
| // table_copy.wast:2699 |
| assert_trap(() => call($49, "test", [23])); |
| |
| // table_copy.wast:2700 |
| assert_return(() => call($49, "test", [24]), 0); |
| |
| // table_copy.wast:2701 |
| assert_return(() => call($49, "test", [25]), 1); |
| |
| // table_copy.wast:2702 |
| assert_return(() => call($49, "test", [26]), 2); |
| |
| // table_copy.wast:2703 |
| assert_return(() => call($49, "test", [27]), 3); |
| |
| // table_copy.wast:2704 |
| assert_return(() => call($49, "test", [28]), 4); |
| |
| // table_copy.wast:2705 |
| assert_return(() => call($49, "test", [29]), 5); |
| |
| // table_copy.wast:2706 |
| assert_return(() => call($49, "test", [30]), 6); |
| |
| // table_copy.wast:2707 |
| assert_return(() => call($49, "test", [31]), 7); |
| |
| // table_copy.wast:2709 |
| let $50 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x91\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x0b\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2735 |
| assert_trap(() => call($50, "run", [21, 21, 16])); |
| |
| // table_copy.wast:2737 |
| assert_trap(() => call($50, "test", [0])); |
| |
| // table_copy.wast:2738 |
| assert_trap(() => call($50, "test", [1])); |
| |
| // table_copy.wast:2739 |
| assert_trap(() => call($50, "test", [2])); |
| |
| // table_copy.wast:2740 |
| assert_trap(() => call($50, "test", [3])); |
| |
| // table_copy.wast:2741 |
| assert_trap(() => call($50, "test", [4])); |
| |
| // table_copy.wast:2742 |
| assert_trap(() => call($50, "test", [5])); |
| |
| // table_copy.wast:2743 |
| assert_trap(() => call($50, "test", [6])); |
| |
| // table_copy.wast:2744 |
| assert_trap(() => call($50, "test", [7])); |
| |
| // table_copy.wast:2745 |
| assert_trap(() => call($50, "test", [8])); |
| |
| // table_copy.wast:2746 |
| assert_trap(() => call($50, "test", [9])); |
| |
| // table_copy.wast:2747 |
| assert_trap(() => call($50, "test", [10])); |
| |
| // table_copy.wast:2748 |
| assert_trap(() => call($50, "test", [11])); |
| |
| // table_copy.wast:2749 |
| assert_trap(() => call($50, "test", [12])); |
| |
| // table_copy.wast:2750 |
| assert_trap(() => call($50, "test", [13])); |
| |
| // table_copy.wast:2751 |
| assert_trap(() => call($50, "test", [14])); |
| |
| // table_copy.wast:2752 |
| assert_trap(() => call($50, "test", [15])); |
| |
| // table_copy.wast:2753 |
| assert_trap(() => call($50, "test", [16])); |
| |
| // table_copy.wast:2754 |
| assert_trap(() => call($50, "test", [17])); |
| |
| // table_copy.wast:2755 |
| assert_trap(() => call($50, "test", [18])); |
| |
| // table_copy.wast:2756 |
| assert_trap(() => call($50, "test", [19])); |
| |
| // table_copy.wast:2757 |
| assert_trap(() => call($50, "test", [20])); |
| |
| // table_copy.wast:2758 |
| assert_return(() => call($50, "test", [21]), 0); |
| |
| // table_copy.wast:2759 |
| assert_return(() => call($50, "test", [22]), 1); |
| |
| // table_copy.wast:2760 |
| assert_return(() => call($50, "test", [23]), 2); |
| |
| // table_copy.wast:2761 |
| assert_return(() => call($50, "test", [24]), 3); |
| |
| // table_copy.wast:2762 |
| assert_return(() => call($50, "test", [25]), 4); |
| |
| // table_copy.wast:2763 |
| assert_return(() => call($50, "test", [26]), 5); |
| |
| // table_copy.wast:2764 |
| assert_return(() => call($50, "test", [27]), 6); |
| |
| // table_copy.wast:2765 |
| assert_return(() => call($50, "test", [28]), 7); |
| |
| // table_copy.wast:2766 |
| assert_return(() => call($50, "test", [29]), 8); |
| |
| // table_copy.wast:2767 |
| assert_return(() => call($50, "test", [30]), 9); |
| |
| // table_copy.wast:2768 |
| assert_return(() => call($50, "test", [31]), 10); |
| |
| // table_copy.wast:2770 |
| let $51 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x97\x80\x80\x80\x00\x01\x00\x41\xf0\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2796 |
| assert_trap(() => call($51, "run", [0, 112, -32])); |
| |
| // table_copy.wast:2798 |
| assert_trap(() => call($51, "test", [0])); |
| |
| // table_copy.wast:2799 |
| assert_trap(() => call($51, "test", [1])); |
| |
| // table_copy.wast:2800 |
| assert_trap(() => call($51, "test", [2])); |
| |
| // table_copy.wast:2801 |
| assert_trap(() => call($51, "test", [3])); |
| |
| // table_copy.wast:2802 |
| assert_trap(() => call($51, "test", [4])); |
| |
| // table_copy.wast:2803 |
| assert_trap(() => call($51, "test", [5])); |
| |
| // table_copy.wast:2804 |
| assert_trap(() => call($51, "test", [6])); |
| |
| // table_copy.wast:2805 |
| assert_trap(() => call($51, "test", [7])); |
| |
| // table_copy.wast:2806 |
| assert_trap(() => call($51, "test", [8])); |
| |
| // table_copy.wast:2807 |
| assert_trap(() => call($51, "test", [9])); |
| |
| // table_copy.wast:2808 |
| assert_trap(() => call($51, "test", [10])); |
| |
| // table_copy.wast:2809 |
| assert_trap(() => call($51, "test", [11])); |
| |
| // table_copy.wast:2810 |
| assert_trap(() => call($51, "test", [12])); |
| |
| // table_copy.wast:2811 |
| assert_trap(() => call($51, "test", [13])); |
| |
| // table_copy.wast:2812 |
| assert_trap(() => call($51, "test", [14])); |
| |
| // table_copy.wast:2813 |
| assert_trap(() => call($51, "test", [15])); |
| |
| // table_copy.wast:2814 |
| assert_trap(() => call($51, "test", [16])); |
| |
| // table_copy.wast:2815 |
| assert_trap(() => call($51, "test", [17])); |
| |
| // table_copy.wast:2816 |
| assert_trap(() => call($51, "test", [18])); |
| |
| // table_copy.wast:2817 |
| assert_trap(() => call($51, "test", [19])); |
| |
| // table_copy.wast:2818 |
| assert_trap(() => call($51, "test", [20])); |
| |
| // table_copy.wast:2819 |
| assert_trap(() => call($51, "test", [21])); |
| |
| // table_copy.wast:2820 |
| assert_trap(() => call($51, "test", [22])); |
| |
| // table_copy.wast:2821 |
| assert_trap(() => call($51, "test", [23])); |
| |
| // table_copy.wast:2822 |
| assert_trap(() => call($51, "test", [24])); |
| |
| // table_copy.wast:2823 |
| assert_trap(() => call($51, "test", [25])); |
| |
| // table_copy.wast:2824 |
| assert_trap(() => call($51, "test", [26])); |
| |
| // table_copy.wast:2825 |
| assert_trap(() => call($51, "test", [27])); |
| |
| // table_copy.wast:2826 |
| assert_trap(() => call($51, "test", [28])); |
| |
| // table_copy.wast:2827 |
| assert_trap(() => call($51, "test", [29])); |
| |
| // table_copy.wast:2828 |
| assert_trap(() => call($51, "test", [30])); |
| |
| // table_copy.wast:2829 |
| assert_trap(() => call($51, "test", [31])); |
| |
| // table_copy.wast:2830 |
| assert_trap(() => call($51, "test", [32])); |
| |
| // table_copy.wast:2831 |
| assert_trap(() => call($51, "test", [33])); |
| |
| // table_copy.wast:2832 |
| assert_trap(() => call($51, "test", [34])); |
| |
| // table_copy.wast:2833 |
| assert_trap(() => call($51, "test", [35])); |
| |
| // table_copy.wast:2834 |
| assert_trap(() => call($51, "test", [36])); |
| |
| // table_copy.wast:2835 |
| assert_trap(() => call($51, "test", [37])); |
| |
| // table_copy.wast:2836 |
| assert_trap(() => call($51, "test", [38])); |
| |
| // table_copy.wast:2837 |
| assert_trap(() => call($51, "test", [39])); |
| |
| // table_copy.wast:2838 |
| assert_trap(() => call($51, "test", [40])); |
| |
| // table_copy.wast:2839 |
| assert_trap(() => call($51, "test", [41])); |
| |
| // table_copy.wast:2840 |
| assert_trap(() => call($51, "test", [42])); |
| |
| // table_copy.wast:2841 |
| assert_trap(() => call($51, "test", [43])); |
| |
| // table_copy.wast:2842 |
| assert_trap(() => call($51, "test", [44])); |
| |
| // table_copy.wast:2843 |
| assert_trap(() => call($51, "test", [45])); |
| |
| // table_copy.wast:2844 |
| assert_trap(() => call($51, "test", [46])); |
| |
| // table_copy.wast:2845 |
| assert_trap(() => call($51, "test", [47])); |
| |
| // table_copy.wast:2846 |
| assert_trap(() => call($51, "test", [48])); |
| |
| // table_copy.wast:2847 |
| assert_trap(() => call($51, "test", [49])); |
| |
| // table_copy.wast:2848 |
| assert_trap(() => call($51, "test", [50])); |
| |
| // table_copy.wast:2849 |
| assert_trap(() => call($51, "test", [51])); |
| |
| // table_copy.wast:2850 |
| assert_trap(() => call($51, "test", [52])); |
| |
| // table_copy.wast:2851 |
| assert_trap(() => call($51, "test", [53])); |
| |
| // table_copy.wast:2852 |
| assert_trap(() => call($51, "test", [54])); |
| |
| // table_copy.wast:2853 |
| assert_trap(() => call($51, "test", [55])); |
| |
| // table_copy.wast:2854 |
| assert_trap(() => call($51, "test", [56])); |
| |
| // table_copy.wast:2855 |
| assert_trap(() => call($51, "test", [57])); |
| |
| // table_copy.wast:2856 |
| assert_trap(() => call($51, "test", [58])); |
| |
| // table_copy.wast:2857 |
| assert_trap(() => call($51, "test", [59])); |
| |
| // table_copy.wast:2858 |
| assert_trap(() => call($51, "test", [60])); |
| |
| // table_copy.wast:2859 |
| assert_trap(() => call($51, "test", [61])); |
| |
| // table_copy.wast:2860 |
| assert_trap(() => call($51, "test", [62])); |
| |
| // table_copy.wast:2861 |
| assert_trap(() => call($51, "test", [63])); |
| |
| // table_copy.wast:2862 |
| assert_trap(() => call($51, "test", [64])); |
| |
| // table_copy.wast:2863 |
| assert_trap(() => call($51, "test", [65])); |
| |
| // table_copy.wast:2864 |
| assert_trap(() => call($51, "test", [66])); |
| |
| // table_copy.wast:2865 |
| assert_trap(() => call($51, "test", [67])); |
| |
| // table_copy.wast:2866 |
| assert_trap(() => call($51, "test", [68])); |
| |
| // table_copy.wast:2867 |
| assert_trap(() => call($51, "test", [69])); |
| |
| // table_copy.wast:2868 |
| assert_trap(() => call($51, "test", [70])); |
| |
| // table_copy.wast:2869 |
| assert_trap(() => call($51, "test", [71])); |
| |
| // table_copy.wast:2870 |
| assert_trap(() => call($51, "test", [72])); |
| |
| // table_copy.wast:2871 |
| assert_trap(() => call($51, "test", [73])); |
| |
| // table_copy.wast:2872 |
| assert_trap(() => call($51, "test", [74])); |
| |
| // table_copy.wast:2873 |
| assert_trap(() => call($51, "test", [75])); |
| |
| // table_copy.wast:2874 |
| assert_trap(() => call($51, "test", [76])); |
| |
| // table_copy.wast:2875 |
| assert_trap(() => call($51, "test", [77])); |
| |
| // table_copy.wast:2876 |
| assert_trap(() => call($51, "test", [78])); |
| |
| // table_copy.wast:2877 |
| assert_trap(() => call($51, "test", [79])); |
| |
| // table_copy.wast:2878 |
| assert_trap(() => call($51, "test", [80])); |
| |
| // table_copy.wast:2879 |
| assert_trap(() => call($51, "test", [81])); |
| |
| // table_copy.wast:2880 |
| assert_trap(() => call($51, "test", [82])); |
| |
| // table_copy.wast:2881 |
| assert_trap(() => call($51, "test", [83])); |
| |
| // table_copy.wast:2882 |
| assert_trap(() => call($51, "test", [84])); |
| |
| // table_copy.wast:2883 |
| assert_trap(() => call($51, "test", [85])); |
| |
| // table_copy.wast:2884 |
| assert_trap(() => call($51, "test", [86])); |
| |
| // table_copy.wast:2885 |
| assert_trap(() => call($51, "test", [87])); |
| |
| // table_copy.wast:2886 |
| assert_trap(() => call($51, "test", [88])); |
| |
| // table_copy.wast:2887 |
| assert_trap(() => call($51, "test", [89])); |
| |
| // table_copy.wast:2888 |
| assert_trap(() => call($51, "test", [90])); |
| |
| // table_copy.wast:2889 |
| assert_trap(() => call($51, "test", [91])); |
| |
| // table_copy.wast:2890 |
| assert_trap(() => call($51, "test", [92])); |
| |
| // table_copy.wast:2891 |
| assert_trap(() => call($51, "test", [93])); |
| |
| // table_copy.wast:2892 |
| assert_trap(() => call($51, "test", [94])); |
| |
| // table_copy.wast:2893 |
| assert_trap(() => call($51, "test", [95])); |
| |
| // table_copy.wast:2894 |
| assert_trap(() => call($51, "test", [96])); |
| |
| // table_copy.wast:2895 |
| assert_trap(() => call($51, "test", [97])); |
| |
| // table_copy.wast:2896 |
| assert_trap(() => call($51, "test", [98])); |
| |
| // table_copy.wast:2897 |
| assert_trap(() => call($51, "test", [99])); |
| |
| // table_copy.wast:2898 |
| assert_trap(() => call($51, "test", [100])); |
| |
| // table_copy.wast:2899 |
| assert_trap(() => call($51, "test", [101])); |
| |
| // table_copy.wast:2900 |
| assert_trap(() => call($51, "test", [102])); |
| |
| // table_copy.wast:2901 |
| assert_trap(() => call($51, "test", [103])); |
| |
| // table_copy.wast:2902 |
| assert_trap(() => call($51, "test", [104])); |
| |
| // table_copy.wast:2903 |
| assert_trap(() => call($51, "test", [105])); |
| |
| // table_copy.wast:2904 |
| assert_trap(() => call($51, "test", [106])); |
| |
| // table_copy.wast:2905 |
| assert_trap(() => call($51, "test", [107])); |
| |
| // table_copy.wast:2906 |
| assert_trap(() => call($51, "test", [108])); |
| |
| // table_copy.wast:2907 |
| assert_trap(() => call($51, "test", [109])); |
| |
| // table_copy.wast:2908 |
| assert_trap(() => call($51, "test", [110])); |
| |
| // table_copy.wast:2909 |
| assert_trap(() => call($51, "test", [111])); |
| |
| // table_copy.wast:2910 |
| assert_return(() => call($51, "test", [112]), 0); |
| |
| // table_copy.wast:2911 |
| assert_return(() => call($51, "test", [113]), 1); |
| |
| // table_copy.wast:2912 |
| assert_return(() => call($51, "test", [114]), 2); |
| |
| // table_copy.wast:2913 |
| assert_return(() => call($51, "test", [115]), 3); |
| |
| // table_copy.wast:2914 |
| assert_return(() => call($51, "test", [116]), 4); |
| |
| // table_copy.wast:2915 |
| assert_return(() => call($51, "test", [117]), 5); |
| |
| // table_copy.wast:2916 |
| assert_return(() => call($51, "test", [118]), 6); |
| |
| // table_copy.wast:2917 |
| assert_return(() => call($51, "test", [119]), 7); |
| |
| // table_copy.wast:2918 |
| assert_return(() => call($51, "test", [120]), 8); |
| |
| // table_copy.wast:2919 |
| assert_return(() => call($51, "test", [121]), 9); |
| |
| // table_copy.wast:2920 |
| assert_return(() => call($51, "test", [122]), 10); |
| |
| // table_copy.wast:2921 |
| assert_return(() => call($51, "test", [123]), 11); |
| |
| // table_copy.wast:2922 |
| assert_return(() => call($51, "test", [124]), 12); |
| |
| // table_copy.wast:2923 |
| assert_return(() => call($51, "test", [125]), 13); |
| |
| // table_copy.wast:2924 |
| assert_return(() => call($51, "test", [126]), 14); |
| |
| // table_copy.wast:2925 |
| assert_return(() => call($51, "test", [127]), 15); |
| |
| // table_copy.wast:2927 |
| let $52 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x96\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b"); |
| |
| // table_copy.wast:2953 |
| assert_trap(() => call($52, "run", [112, 0, -32])); |
| |
| // table_copy.wast:2955 |
| assert_return(() => call($52, "test", [0]), 0); |
| |
| // table_copy.wast:2956 |
| assert_return(() => call($52, "test", [1]), 1); |
| |
| // table_copy.wast:2957 |
| assert_return(() => call($52, "test", [2]), 2); |
| |
| // table_copy.wast:2958 |
| assert_return(() => call($52, "test", [3]), 3); |
| |
| // table_copy.wast:2959 |
| assert_return(() => call($52, "test", [4]), 4); |
| |
| // table_copy.wast:2960 |
| assert_return(() => call($52, "test", [5]), 5); |
| |
| // table_copy.wast:2961 |
| assert_return(() => call($52, "test", [6]), 6); |
| |
| // table_copy.wast:2962 |
| assert_return(() => call($52, "test", [7]), 7); |
| |
| // table_copy.wast:2963 |
| assert_return(() => call($52, "test", [8]), 8); |
| |
| // table_copy.wast:2964 |
| assert_return(() => call($52, "test", [9]), 9); |
| |
| // table_copy.wast:2965 |
| assert_return(() => call($52, "test", [10]), 10); |
| |
| // table_copy.wast:2966 |
| assert_return(() => call($52, "test", [11]), 11); |
| |
| // table_copy.wast:2967 |
| assert_return(() => call($52, "test", [12]), 12); |
| |
| // table_copy.wast:2968 |
| assert_return(() => call($52, "test", [13]), 13); |
| |
| // table_copy.wast:2969 |
| assert_return(() => call($52, "test", [14]), 14); |
| |
| // table_copy.wast:2970 |
| assert_return(() => call($52, "test", [15]), 15); |
| |
| // table_copy.wast:2971 |
| assert_trap(() => call($52, "test", [16])); |
| |
| // table_copy.wast:2972 |
| assert_trap(() => call($52, "test", [17])); |
| |
| // table_copy.wast:2973 |
| assert_trap(() => call($52, "test", [18])); |
| |
| // table_copy.wast:2974 |
| assert_trap(() => call($52, "test", [19])); |
| |
| // table_copy.wast:2975 |
| assert_trap(() => call($52, "test", [20])); |
| |
| // table_copy.wast:2976 |
| assert_trap(() => call($52, "test", [21])); |
| |
| // table_copy.wast:2977 |
| assert_trap(() => call($52, "test", [22])); |
| |
| // table_copy.wast:2978 |
| assert_trap(() => call($52, "test", [23])); |
| |
| // table_copy.wast:2979 |
| assert_trap(() => call($52, "test", [24])); |
| |
| // table_copy.wast:2980 |
| assert_trap(() => call($52, "test", [25])); |
| |
| // table_copy.wast:2981 |
| assert_trap(() => call($52, "test", [26])); |
| |
| // table_copy.wast:2982 |
| assert_trap(() => call($52, "test", [27])); |
| |
| // table_copy.wast:2983 |
| assert_trap(() => call($52, "test", [28])); |
| |
| // table_copy.wast:2984 |
| assert_trap(() => call($52, "test", [29])); |
| |
| // table_copy.wast:2985 |
| assert_trap(() => call($52, "test", [30])); |
| |
| // table_copy.wast:2986 |
| assert_trap(() => call($52, "test", [31])); |
| |
| // table_copy.wast:2987 |
| assert_trap(() => call($52, "test", [32])); |
| |
| // table_copy.wast:2988 |
| assert_trap(() => call($52, "test", [33])); |
| |
| // table_copy.wast:2989 |
| assert_trap(() => call($52, "test", [34])); |
| |
| // table_copy.wast:2990 |
| assert_trap(() => call($52, "test", [35])); |
| |
| // table_copy.wast:2991 |
| assert_trap(() => call($52, "test", [36])); |
| |
| // table_copy.wast:2992 |
| assert_trap(() => call($52, "test", [37])); |
| |
| // table_copy.wast:2993 |
| assert_trap(() => call($52, "test", [38])); |
| |
| // table_copy.wast:2994 |
| assert_trap(() => call($52, "test", [39])); |
| |
| // table_copy.wast:2995 |
| assert_trap(() => call($52, "test", [40])); |
| |
| // table_copy.wast:2996 |
| assert_trap(() => call($52, "test", [41])); |
| |
| // table_copy.wast:2997 |
| assert_trap(() => call($52, "test", [42])); |
| |
| // table_copy.wast:2998 |
| assert_trap(() => call($52, "test", [43])); |
| |
| // table_copy.wast:2999 |
| assert_trap(() => call($52, "test", [44])); |
| |
| // table_copy.wast:3000 |
| assert_trap(() => call($52, "test", [45])); |
| |
| // table_copy.wast:3001 |
| assert_trap(() => call($52, "test", [46])); |
| |
| // table_copy.wast:3002 |
| assert_trap(() => call($52, "test", [47])); |
| |
| // table_copy.wast:3003 |
| assert_trap(() => call($52, "test", [48])); |
| |
| // table_copy.wast:3004 |
| assert_trap(() => call($52, "test", [49])); |
| |
| // table_copy.wast:3005 |
| assert_trap(() => call($52, "test", [50])); |
| |
| // table_copy.wast:3006 |
| assert_trap(() => call($52, "test", [51])); |
| |
| // table_copy.wast:3007 |
| assert_trap(() => call($52, "test", [52])); |
| |
| // table_copy.wast:3008 |
| assert_trap(() => call($52, "test", [53])); |
| |
| // table_copy.wast:3009 |
| assert_trap(() => call($52, "test", [54])); |
| |
| // table_copy.wast:3010 |
| assert_trap(() => call($52, "test", [55])); |
| |
| // table_copy.wast:3011 |
| assert_trap(() => call($52, "test", [56])); |
| |
| // table_copy.wast:3012 |
| assert_trap(() => call($52, "test", [57])); |
| |
| // table_copy.wast:3013 |
| assert_trap(() => call($52, "test", [58])); |
| |
| // table_copy.wast:3014 |
| assert_trap(() => call($52, "test", [59])); |
| |
| // table_copy.wast:3015 |
| assert_trap(() => call($52, "test", [60])); |
| |
| // table_copy.wast:3016 |
| assert_trap(() => call($52, "test", [61])); |
| |
| // table_copy.wast:3017 |
| assert_trap(() => call($52, "test", [62])); |
| |
| // table_copy.wast:3018 |
| assert_trap(() => call($52, "test", [63])); |
| |
| // table_copy.wast:3019 |
| assert_trap(() => call($52, "test", [64])); |
| |
| // table_copy.wast:3020 |
| assert_trap(() => call($52, "test", [65])); |
| |
| // table_copy.wast:3021 |
| assert_trap(() => call($52, "test", [66])); |
| |
| // table_copy.wast:3022 |
| assert_trap(() => call($52, "test", [67])); |
| |
| // table_copy.wast:3023 |
| assert_trap(() => call($52, "test", [68])); |
| |
| // table_copy.wast:3024 |
| assert_trap(() => call($52, "test", [69])); |
| |
| // table_copy.wast:3025 |
| assert_trap(() => call($52, "test", [70])); |
| |
| // table_copy.wast:3026 |
| assert_trap(() => call($52, "test", [71])); |
| |
| // table_copy.wast:3027 |
| assert_trap(() => call($52, "test", [72])); |
| |
| // table_copy.wast:3028 |
| assert_trap(() => call($52, "test", [73])); |
| |
| // table_copy.wast:3029 |
| assert_trap(() => call($52, "test", [74])); |
| |
| // table_copy.wast:3030 |
| assert_trap(() => call($52, "test", [75])); |
| |
| // table_copy.wast:3031 |
| assert_trap(() => call($52, "test", [76])); |
| |
| // table_copy.wast:3032 |
| assert_trap(() => call($52, "test", [77])); |
| |
| // table_copy.wast:3033 |
| assert_trap(() => call($52, "test", [78])); |
| |
| // table_copy.wast:3034 |
| assert_trap(() => call($52, "test", [79])); |
| |
| // table_copy.wast:3035 |
| assert_trap(() => call($52, "test", [80])); |
| |
| // table_copy.wast:3036 |
| assert_trap(() => call($52, "test", [81])); |
| |
| // table_copy.wast:3037 |
| assert_trap(() => call($52, "test", [82])); |
| |
| // table_copy.wast:3038 |
| assert_trap(() => call($52, "test", [83])); |
| |
| // table_copy.wast:3039 |
| assert_trap(() => call($52, "test", [84])); |
| |
| // table_copy.wast:3040 |
| assert_trap(() => call($52, "test", [85])); |
| |
| // table_copy.wast:3041 |
| assert_trap(() => call($52, "test", [86])); |
| |
| // table_copy.wast:3042 |
| assert_trap(() => call($52, "test", [87])); |
| |
| // table_copy.wast:3043 |
| assert_trap(() => call($52, "test", [88])); |
| |
| // table_copy.wast:3044 |
| assert_trap(() => call($52, "test", [89])); |
| |
| // table_copy.wast:3045 |
| assert_trap(() => call($52, "test", [90])); |
| |
| // table_copy.wast:3046 |
| assert_trap(() => call($52, "test", [91])); |
| |
| // table_copy.wast:3047 |
| assert_trap(() => call($52, "test", [92])); |
| |
| // table_copy.wast:3048 |
| assert_trap(() => call($52, "test", [93])); |
| |
| // table_copy.wast:3049 |
| assert_trap(() => call($52, "test", [94])); |
| |
| // table_copy.wast:3050 |
| assert_trap(() => call($52, "test", [95])); |
| |
| // table_copy.wast:3051 |
| assert_trap(() => call($52, "test", [96])); |
| |
| // table_copy.wast:3052 |
| assert_trap(() => call($52, "test", [97])); |
| |
| // table_copy.wast:3053 |
| assert_trap(() => call($52, "test", [98])); |
| |
| // table_copy.wast:3054 |
| assert_trap(() => call($52, "test", [99])); |
| |
| // table_copy.wast:3055 |
| assert_trap(() => call($52, "test", [100])); |
| |
| // table_copy.wast:3056 |
| assert_trap(() => call($52, "test", [101])); |
| |
| // table_copy.wast:3057 |
| assert_trap(() => call($52, "test", [102])); |
| |
| // table_copy.wast:3058 |
| assert_trap(() => call($52, "test", [103])); |
| |
| // table_copy.wast:3059 |
| assert_trap(() => call($52, "test", [104])); |
| |
| // table_copy.wast:3060 |
| assert_trap(() => call($52, "test", [105])); |
| |
| // table_copy.wast:3061 |
| assert_trap(() => call($52, "test", [106])); |
| |
| // table_copy.wast:3062 |
| assert_trap(() => call($52, "test", [107])); |
| |
| // table_copy.wast:3063 |
| assert_trap(() => call($52, "test", [108])); |
| |
| // table_copy.wast:3064 |
| assert_trap(() => call($52, "test", [109])); |
| |
| // table_copy.wast:3065 |
| assert_trap(() => call($52, "test", [110])); |
| |
| // table_copy.wast:3066 |
| assert_trap(() => call($52, "test", [111])); |
| |
| // table_copy.wast:3067 |
| assert_trap(() => call($52, "test", [112])); |
| |
| // table_copy.wast:3068 |
| assert_trap(() => call($52, "test", [113])); |
| |
| // table_copy.wast:3069 |
| assert_trap(() => call($52, "test", [114])); |
| |
| // table_copy.wast:3070 |
| assert_trap(() => call($52, "test", [115])); |
| |
| // table_copy.wast:3071 |
| assert_trap(() => call($52, "test", [116])); |
| |
| // table_copy.wast:3072 |
| assert_trap(() => call($52, "test", [117])); |
| |
| // table_copy.wast:3073 |
| assert_trap(() => call($52, "test", [118])); |
| |
| // table_copy.wast:3074 |
| assert_trap(() => call($52, "test", [119])); |
| |
| // table_copy.wast:3075 |
| assert_trap(() => call($52, "test", [120])); |
| |
| // table_copy.wast:3076 |
| assert_trap(() => call($52, "test", [121])); |
| |
| // table_copy.wast:3077 |
| assert_trap(() => call($52, "test", [122])); |
| |
| // table_copy.wast:3078 |
| assert_trap(() => call($52, "test", [123])); |
| |
| // table_copy.wast:3079 |
| assert_trap(() => call($52, "test", [124])); |
| |
| // table_copy.wast:3080 |
| assert_trap(() => call($52, "test", [125])); |
| |
| // table_copy.wast:3081 |
| assert_trap(() => call($52, "test", [126])); |
| |
| // table_copy.wast:3082 |
| assert_trap(() => call($52, "test", [127])); |
