OLD | NEW |
1 // Copyright 2016 the V8 project authors. All rights reserved. | 1 // Copyright 2016 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Flags: --expose-wasm --allow-natives-syntax | 5 // Flags: --expose-wasm --allow-natives-syntax |
6 | 6 |
7 load('test/mjsunit/wasm/wasm-constants.js'); | 7 load('test/mjsunit/wasm/wasm-constants.js'); |
8 load('test/mjsunit/wasm/wasm-module-builder.js'); | 8 load('test/mjsunit/wasm/wasm-module-builder.js'); |
9 | 9 |
10 function unexpectedSuccess() { | 10 function unexpectedSuccess() { |
(...skipping 347 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
358 'first argument must be a WebAssembly.Module'); | 358 'first argument must be a WebAssembly.Module'); |
359 assertErrorMessage( | 359 assertErrorMessage( |
360 () => new Instance(emptyModule, null), TypeError, | 360 () => new Instance(emptyModule, null), TypeError, |
361 'second argument must be an object'); | 361 'second argument must be an object'); |
362 assertErrorMessage(() => new Instance(importingModule, null), TypeError, ''); | 362 assertErrorMessage(() => new Instance(importingModule, null), TypeError, ''); |
363 assertErrorMessage( | 363 assertErrorMessage( |
364 () => new Instance(importingModule, undefined), TypeError, ''); | 364 () => new Instance(importingModule, undefined), TypeError, ''); |
365 assertErrorMessage( | 365 assertErrorMessage( |
366 () => new Instance(importingModule, {'': {g: () => {}}}), LinkError, ''); | 366 () => new Instance(importingModule, {'': {g: () => {}}}), LinkError, ''); |
367 assertErrorMessage( | 367 assertErrorMessage( |
368 () => new Instance(importingModule, {t: {f: () => {}}}), LinkError, ''); | 368 () => new Instance(importingModule, {t: {f: () => {}}}), TypeError, ''); |
369 | 369 |
370 assertTrue(new Instance(emptyModule) instanceof Instance); | 370 assertTrue(new Instance(emptyModule) instanceof Instance); |
371 assertTrue(new Instance(emptyModule, {}) instanceof Instance); | 371 assertTrue(new Instance(emptyModule, {}) instanceof Instance); |
372 | 372 |
373 // 'WebAssembly.Instance.prototype' data property | 373 // 'WebAssembly.Instance.prototype' data property |
374 let instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype'); | 374 let instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype'); |
375 assertEq(typeof instanceProtoDesc.value, 'object'); | 375 assertEq(typeof instanceProtoDesc.value, 'object'); |
376 assertFalse(instanceProtoDesc.writable); | 376 assertFalse(instanceProtoDesc.writable); |
377 assertFalse(instanceProtoDesc.enumerable); | 377 assertFalse(instanceProtoDesc.enumerable); |
378 assertFalse(instanceProtoDesc.configurable); | 378 assertFalse(instanceProtoDesc.configurable); |
(...skipping 407 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
786 assertInstantiateError( | 786 assertInstantiateError( |
787 [importingModuleBinary, null], TypeError, | 787 [importingModuleBinary, null], TypeError, |
788 /second argument must be an object/); | 788 /second argument must be an object/); |
789 assertInstantiateError( | 789 assertInstantiateError( |
790 [emptyModule, null], TypeError, /first argument must be a BufferSource/); | 790 [emptyModule, null], TypeError, /first argument must be a BufferSource/); |
791 assertInstantiateError( | 791 assertInstantiateError( |
792 [importingModuleBinary, null], TypeError, /TODO: error messages?/); | 792 [importingModuleBinary, null], TypeError, /TODO: error messages?/); |
793 assertInstantiateError( | 793 assertInstantiateError( |
794 [importingModuleBinary, undefined], TypeError, /TODO: error messages?/); | 794 [importingModuleBinary, undefined], TypeError, /TODO: error messages?/); |
795 assertInstantiateError( | 795 assertInstantiateError( |
796 [importingModuleBinary, {}], LinkError, /TODO: error messages?/); | 796 [importingModuleBinary, {}], TypeError, /TODO: error messages?/); |
797 assertInstantiateError( | 797 assertInstantiateError( |
798 [importingModuleBinary, {'': {g: () => {}}}], LinkError, | 798 [importingModuleBinary, {'': {g: () => {}}}], LinkError, |
799 /TODO: error messages?/); | 799 /TODO: error messages?/); |
800 assertInstantiateError( | 800 assertInstantiateError( |
801 [importingModuleBinary, {t: {f: () => {}}}], LinkError, | 801 [importingModuleBinary, {t: {f: () => {}}}], TypeError, |
802 /TODO: error messages?/); | 802 /TODO: error messages?/); |
803 assertInstantiateError( | 803 assertInstantiateError( |
804 [memoryImportingModuleBinary, null], TypeError, /TODO: error messages?/); | 804 [memoryImportingModuleBinary, null], TypeError, /TODO: error messages?/); |
805 assertInstantiateError( | 805 assertInstantiateError( |
806 [memoryImportingModuleBinary, undefined], TypeError, | 806 [memoryImportingModuleBinary, undefined], TypeError, |
807 /TODO: error messages?/); | 807 /TODO: error messages?/); |
808 assertInstantiateError( | 808 assertInstantiateError( |
809 [memoryImportingModuleBinary, {}], LinkError, /TODO: error messages?/); | 809 [memoryImportingModuleBinary, {}], TypeError, /TODO: error messages?/); |
810 assertInstantiateError( | 810 assertInstantiateError( |
811 [memoryImportingModuleBinary, {'mod': {'my_memory': scratch_memory}}], | 811 [memoryImportingModuleBinary, {'mod': {'my_memory': scratch_memory}}], |
812 LinkError, /TODO: error messages?/); | 812 TypeError, /TODO: error messages?/); |
813 assertInstantiateError( | 813 assertInstantiateError( |
814 [memoryImportingModuleBinary, {'': {'memory': scratch_memory}}], LinkError, | 814 [memoryImportingModuleBinary, {'': {'memory': scratch_memory}}], LinkError, |
815 /TODO: error messages?/); | 815 /TODO: error messages?/); |
816 | 816 |
817 function assertInstantiateSuccess(module_or_bytes, imports) { | 817 function assertInstantiateSuccess(module_or_bytes, imports) { |
818 var result = null; | 818 var result = null; |
819 assertPromiseResult(instantiate(module_or_bytes, imports), result => { | 819 assertPromiseResult(instantiate(module_or_bytes, imports), result => { |
820 if (module_or_bytes instanceof Module) { | 820 if (module_or_bytes instanceof Module) { |
821 assertTrue(result instanceof Instance); | 821 assertTrue(result instanceof Instance); |
822 } else { | 822 } else { |
823 assertTrue(result.module instanceof Module); | 823 assertTrue(result.module instanceof Module); |
824 assertTrue(result.instance instanceof Instance); | 824 assertTrue(result.instance instanceof Instance); |
825 } | 825 } |
826 }); | 826 }); |
827 } | 827 } |
828 assertInstantiateSuccess(emptyModule); | 828 assertInstantiateSuccess(emptyModule); |
829 assertInstantiateSuccess(emptyModuleBinary); | 829 assertInstantiateSuccess(emptyModuleBinary); |
830 assertInstantiateSuccess(emptyModuleBinary.buffer); | 830 assertInstantiateSuccess(emptyModuleBinary.buffer); |
831 assertInstantiateSuccess(importingModule, {'': {f: () => {}}}); | 831 assertInstantiateSuccess(importingModule, {'': {f: () => {}}}); |
832 assertInstantiateSuccess(importingModuleBinary, {'': {f: () => {}}}); | 832 assertInstantiateSuccess(importingModuleBinary, {'': {f: () => {}}}); |
833 assertInstantiateSuccess(importingModuleBinary.buffer, {'': {f: () => {}}}); | 833 assertInstantiateSuccess(importingModuleBinary.buffer, {'': {f: () => {}}}); |
834 assertInstantiateSuccess( | 834 assertInstantiateSuccess( |
835 memoryImportingModuleBinary, {'': {'my_memory': scratch_memory}}); | 835 memoryImportingModuleBinary, {'': {'my_memory': scratch_memory}}); |
OLD | NEW |