git ssb

0+

wanderer🌟 / js-primea-wasm-container



Commit 37c7dd279bc8cf3ec9bd6b9a679b192ea01f1cdb

Browse Files

updated tests

Signed-off-by: wanderer <mjbecze@gmail.com>
wanderer committed on 10/16/2017, 2:16:59 AM
Parent: 7e8260c7fe3763cd192cd67f67e3813912a97086

Files changed

index.jschanged
package.jsonchanged
tests/index.jschanged
index.jsView
@@ -16,9 +16,9 @@
1616 this.referanceMap = new ReferanceMap()
1717 }
1818
1919 async onCreation (message) {
20- let code = message.data
20+ let code = message.data.code
2121 if (!WebAssembly.validate(code)) {
2222 throw new Error('invalid wasm binary')
2323 } else {
2424 for (const name in this.imports) {
package.jsonView
@@ -22,17 +22,17 @@
2222 "prima"
2323 ],
2424 "devDependencies": {
2525 "coveralls": "^3.0.0",
26- "ipfs": "^0.26.0",
27- "istanbul": "^1.1.0-alpha.1",
2826 "primea-hypervisor": "0.1.0",
27+ "primea-message": "0.0.2",
2928 "standard": "^10.0.0",
3029 "tape": "^4.6.3",
3130 "wast2wasm": "0.0.1"
3231 },
3332 "dependencies": {
3433 "primea-abstract-container": "0.0.5",
34+ "dfinity-radix-tree": "0.0.2",
3535 "primea-container-table": "0.0.0",
3636 "reference-map": "1.0.0"
3737 }
3838 }
tests/index.jsView
@@ -3,12 +3,14 @@
33 const Hypervisor = require('primea-hypervisor')
44 const Message = require('primea-message')
55 const WasmContainer = require('../index.js')
66 const testInterface = require('./testInterface.js')
7-const IPFS = require('ipfs')
7+const level = require('level')
8+const RadixTree = require('dfinity-radix-tree')
9+const db = level('./testdb')
810
9-const node = new IPFS({
10- start: false
11+const tree = new RadixTree({
12+ db: db
1113 })
1214
1315 class ContainerTestInterface {
1416 constructor (wasmContainer) {
@@ -35,141 +37,165 @@
3537 this.wasmContainer.execute(cb)
3638 }
3739 }
3840
39-node.on('ready', () => {
40- tape('wasm container - main', async t => {
41- t.plan(1)
42- const hypervisor = new Hypervisor(node.dag)
43- const main = fs.readFileSync(`${__dirname}/wasm/run.wasm`)
44- hypervisor.registerContainer(WasmContainer, {
45- test: testInterface(t)
46- })
47- const instance = await hypervisor.createInstance(WasmContainer.typeId, new Message({
48- data: main
49- }))
50- instance.message(instance.createMessage())
41+tape('wasm container - main', async t => {
42+ t.plan(1)
43+ const hypervisor = new Hypervisor(tree)
44+ const main = fs.readFileSync(`${__dirname}/wasm/run.wasm`)
45+ hypervisor.registerContainer(WasmContainer, {
46+ test: testInterface(t)
5147 })
5248
53- tape('referances', async t => {
54- t.plan(1)
55- const hypervisor = new Hypervisor(node.dag)
56- const main = fs.readFileSync(`${__dirname}/wasm/referances.wasm`)
57- hypervisor.registerContainer(WasmContainer, {
58- env: ContainerTestInterface,
59- test: testInterface(t)
60- })
61- const ports = hypervisor.createChannel()
62- await hypervisor.createInstance(WasmContainer.typeId, new Message({
63- data: main,
64- ports: ports
65- }))
66- })
49+ const port = hypervisor.creationService.getPort()
6750
68- tape('wasm container - mem', async t => {
69- t.plan(1)
70- try {
71- const hypervisor = new Hypervisor(node.dag)
72- const readMem = fs.readFileSync(`${__dirname}/wasm/readMem.wasm`)
73- hypervisor.registerContainer(WasmContainer, {
74- env: ContainerTestInterface,
75- test: testInterface(t)
76- })
77- await hypervisor.createInstance(WasmContainer.typeId, new Message({
78- data: readMem
79- }))
80- } catch (e) {
81- console.log(e)
51+ let instance = await hypervisor.send(port, new Message({
52+ data: {
53+ type: WasmContainer.typeId,
54+ code: main
8255 }
56+ }))
57+ instance.message(instance.createMessage())
58+})
59+
60+tape('referances', async t => {
61+ t.plan(1)
62+ const hypervisor = new Hypervisor(tree)
63+ const main = fs.readFileSync(`${__dirname}/wasm/referances.wasm`)
64+ hypervisor.registerContainer(WasmContainer, {
65+ env: ContainerTestInterface,
66+ test: testInterface(t)
8367 })
68+ const ports = hypervisor.createChannel()
69+ const port = hypervisor.creationService.getPort()
8470
85- tape('write mem', async t => {
86- try {
87- const hypervisor = new Hypervisor(node.dag)
88- const readMem = fs.readFileSync(`${__dirname}/wasm/writeMem.wasm`)
89- hypervisor.registerContainer(WasmContainer, {
90- env: ContainerTestInterface,
91- test: testInterface(t)
92- })
93- const root = await hypervisor.createInstance(WasmContainer.typeId, new Message({
94- data: readMem
95- }))
96- const mem = root.container.getMemory(0, 1)
97- t.equals(mem[0], 9)
98- t.end()
99- } catch (e) {
100- console.log(e)
101- }
71+ hypervisor.send(port, new Message({
72+ data: {
73+ type: WasmContainer.typeId,
74+ code: main
75+ },
76+ ports: ports
77+ }))
78+})
79+
80+tape('wasm container - mem', async t => {
81+ t.plan(1)
82+ const hypervisor = new Hypervisor(tree)
83+ const readMem = fs.readFileSync(`${__dirname}/wasm/readMem.wasm`)
84+ hypervisor.registerContainer(WasmContainer, {
85+ env: ContainerTestInterface,
86+ test: testInterface(t)
10287 })
10388
104- tape('wasm container - callbacks', async t => {
105- t.plan(1)
106- const hypervisor = new Hypervisor(node.dag)
107- const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
108- hypervisor.registerContainer(WasmContainer, {
109- env: ContainerTestInterface,
110- test: testInterface(t)
111- })
112- hypervisor.createInstance(WasmContainer.typeId, new Message({
113- data: callBackWasm
114- }))
89+ const port = hypervisor.creationService.getPort()
90+
91+ hypervisor.send(port, new Message({
92+ data: {
93+ type: WasmContainer.typeId,
94+ code: readMem
95+ }
96+ }))
97+})
98+
99+tape('write mem', async t => {
100+ const hypervisor = new Hypervisor(tree)
101+ const readMem = fs.readFileSync(`${__dirname}/wasm/writeMem.wasm`)
102+ hypervisor.registerContainer(WasmContainer, {
103+ env: ContainerTestInterface,
104+ test: testInterface(t)
115105 })
116106
117- tape('wasm container - invalid', async t => {
118- t.plan(1)
119- const hypervisor = new Hypervisor(node.dag)
120- hypervisor.registerContainer(WasmContainer, {
121- env: ContainerTestInterface,
122- test: testInterface(t)
123- })
107+ const port = hypervisor.creationService.getPort()
108+ const root = await hypervisor.send(port, new Message({
109+ data: {
110+ type: WasmContainer.typeId,
111+ code: readMem
112+ }
113+ }))
114+ const mem = root.container.getMemory(0, 1)
115+ t.equals(mem[0], 9)
116+ t.end()
117+})
124118
125- const message = new Message({
126- data: Buffer.from([0x00])
127- })
119+tape('wasm container - callbacks', async t => {
120+ t.plan(1)
121+ const hypervisor = new Hypervisor(tree)
122+ const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
123+ hypervisor.registerContainer(WasmContainer, {
124+ env: ContainerTestInterface,
125+ test: testInterface(t)
126+ })
128127
129- const rp = message.responsePort = {destPort: {messages: []}}
128+ const port = hypervisor.creationService.getPort()
129+ await hypervisor.send(port, new Message({
130+ data: {
131+ type: WasmContainer.typeId,
132+ code: callBackWasm
133+ }
134+ }))
135+})
130136
131- await hypervisor.createInstance(WasmContainer.typeId, message)
132- t.equals(rp.destPort.messages[0].data.exception, true)
137+tape('wasm container - invalid', async t => {
138+ t.plan(1)
139+ const hypervisor = new Hypervisor(tree)
140+ hypervisor.registerContainer(WasmContainer, {
141+ env: ContainerTestInterface,
142+ test: testInterface(t)
133143 })
134144
135- tape('initailize', async t => {
136- t.plan(2)
145+ const message = new Message({
146+ data: {
147+ type: WasmContainer.typeId,
148+ code: Buffer.from([0x00])
149+ }
150+ })
137151
138- const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
152+ const rp = message.responsePort = {destPort: {messages: []}}
139153
140- class ContainerTestInterface {
141- constructor (wasmContainer) {
142- this.wasmContainer = wasmContainer
143- }
154+ const port = hypervisor.creationService.getPort()
155+ await hypervisor.send(port, message)
144156
145- readMem (offset) {
146- return this.wasmContainer.getMemory(offset, 1)
147- }
157+ t.equals(rp.destPort.messages[0].data.exception, true)
158+})
148159
149- async callback (cb) {
150- const promise = new Promise((resolve, reject) => {
151- resolve()
152- })
153- await this.wasmContainer.pushOpsQueue(promise)
154- this.wasmContainer.execute(cb)
155- }
160+tape('initailize', async t => {
161+ t.plan(2)
156162
157- static initialize (code) {
158- t.equals(code, callBackWasm)
159- return code
160- }
163+ const callBackWasm = fs.readFileSync(`${__dirname}/wasm/callback.wasm`)
164+
165+ class ContainerTestInterface {
166+ constructor (wasmContainer) {
167+ this.wasmContainer = wasmContainer
161168 }
162169
163- const hypervisor = new Hypervisor(node.dag)
164- hypervisor.registerContainer(WasmContainer, {
165- env: ContainerTestInterface,
166- test: testInterface(t)
167- })
170+ readMem (offset) {
171+ return this.wasmContainer.getMemory(offset, 1)
172+ }
168173
169- const message = new Message({
170- data: callBackWasm
171- })
174+ async callback (cb) {
175+ const promise = new Promise((resolve, reject) => {
176+ resolve()
177+ })
178+ await this.wasmContainer.pushOpsQueue(promise)
179+ this.wasmContainer.execute(cb)
180+ }
172181
173- hypervisor.createInstance(WasmContainer.typeId, message)
182+ static initialize (code) {
183+ t.equals(code, callBackWasm)
184+ return code
185+ }
186+ }
187+
188+ const hypervisor = new Hypervisor(tree)
189+ hypervisor.registerContainer(WasmContainer, {
190+ env: ContainerTestInterface,
191+ test: testInterface(t)
174192 })
193+
194+ const port = hypervisor.creationService.getPort()
195+ hypervisor.send(port, new Message({
196+ data: {
197+ type: WasmContainer.typeId,
198+ code: callBackWasm
199+ }
200+ }))
175201 })

Built with git-ssb-web