git ssb

1
const tape = require('tape')
2
const AbstractContainer = require('primea-abstract-container')
3
const Message = require('primea-message')
4
const Hypervisor = require('../')
5
const CapsManager = require('../capsManager.js')
6
7
const level = require('level')
8
const RadixTree = require('dfinity-radix-tree')
9
const db = level('./testdb')
10
11
class BaseContainer extends AbstractContainer {
12
  onCreation () {}
13
  static get typeId () {
14
    return 9
15
  }
16
}
17
18
tape('basic', async t => {
19
  t.plan(2)
20
  let message
21
  const expectedState = {
22
    '/': Buffer.from('70a9676b7995b108057bd29955e3874401aa5ba7', 'hex')
23
  }
24
25
  const tree = new RadixTree({
26
    db: db
27
  })
28
29
  class testVMContainer extends BaseContainer {
30
    onMessage (m, tag) {
31
      t.true(m === message, 'should recive a message')
32
    }
33
  }
34
35
  const hypervisor = new Hypervisor(tree)
36
  hypervisor.registerContainer(testVMContainer)
37
38
  let rootCap = await hypervisor.createActor(testVMContainer.typeId, new Message())
39
40
  message = new Message()
41
  hypervisor.send(rootCap, message)
42
43
  const stateRoot = await hypervisor.createStateRoot(Infinity)
44
  t.deepEquals(stateRoot, expectedState, 'expected root!')
45
})
46
47
tape('caps manager', async t => {
48
  const capsManager = new CapsManager({})
49
  const cap = {}
50
  capsManager.store('test', cap)
51
  const c = capsManager.get('test')
52
  t.equals(cap, c)
53
  capsManager.delete('test')
54
  const empty = capsManager.get('test')
55
  t.equals(empty, undefined)
56
  t.end()
57
})
58
59
tape('two communicating actors', async t => {
60
  t.plan(2)
61
  let message
62
  const expectedState = {
63
    '/': Buffer.from('fc935489953ed357f06171dd23439d83190b3a1b', 'hex')
64
  }
65
66
  const tree = new RadixTree({
67
    db: db
68
  })
69
70
  class testVMContainerA extends BaseContainer {
71
    onCreation (m) {
72
      message = new Message()
73
      return this.actor.send(m.caps[0], message)
74
    }
75
  }
76
77
  class testVMContainerB extends BaseContainer {
78
    onMessage (m) {
79
      t.true(m === message, 'should recive a message')
80
    }
81
82
    static get typeId () {
83
      return 8
84
    }
85
  }
86
87
  const hypervisor = new Hypervisor(tree)
88
  hypervisor.registerContainer(testVMContainerA)
89
  hypervisor.registerContainer(testVMContainerB)
90
91
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
92
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
93
    caps: [capB]
94
  }))
95
96
  const stateRoot = await hypervisor.createStateRoot(Infinity)
97
98
  t.deepEquals(stateRoot, expectedState, 'expected root!')
99
})
100
101
tape('three communicating actors', async t => {
102
  t.plan(3)
103
  let message
104
  const expectedState = {
105
    '/': Buffer.from('24855a8efa9af536f0f9b319c05b10d6b7cae6c8', 'hex')
106
  }
107
108
  const tree = new RadixTree({
109
    db: db
110
  })
111
112
  class testVMContainerA extends BaseContainer {
113
    onCreation (m) {
114
      message = new Message()
115
      return this.actor.send(m.caps[0], message)
116
    }
117
  }
118
119
  class testVMContainerB extends BaseContainer {
120
    onMessage (m) {
121
      t.true(m === message, 'should recive a message')
122
    }
123
124
    static get typeId () {
125
      return 8
126
    }
127
  }
128
129
  const hypervisor = new Hypervisor(tree)
130
  hypervisor.registerContainer(testVMContainerA)
131
  hypervisor.registerContainer(testVMContainerB)
132
133
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
134
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
135
    caps: [capB]
136
  }))
137
138
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
139
    caps: [capB]
140
  }))
141
142
  const stateRoot = await hypervisor.createStateRoot(Infinity)
143
144
  t.deepEquals(stateRoot, expectedState, 'expected root!')
145
})
146
147
tape('three communicating actors, with tick counting', async t => {
148
  t.plan(3)
149
  let message
150
  const expectedState = {
151
    '/': Buffer.from('24855a8efa9af536f0f9b319c05b10d6b7cae6c8', 'hex')
152
  }
153
154
  const tree = new RadixTree({
155
    db: db
156
  })
157
158
  let ticks = 1
159
160
  class testVMContainerA extends BaseContainer {
161
    async onCreation (m) {
162
      this.actor.incrementTicks(ticks)
163
      ticks++
164
      message = new Message()
165
      await this.actor.send(m.caps[0], message)
166
    }
167
  }
168
169
  class testVMContainerB extends BaseContainer {
170
    onMessage (m) {
171
      t.true(m, 'should recive a message')
172
      return new Promise((resolve, reject) => {
173
        setTimeout(resolve, 200)
174
      })
175
    }
176
177
    static get typeId () {
178
      return 8
179
    }
180
  }
181
182
  const hypervisor = new Hypervisor(tree)
183
  hypervisor.registerContainer(testVMContainerA)
184
  hypervisor.registerContainer(testVMContainerB)
185
186
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
187
  hypervisor.createActor(testVMContainerA.typeId, new Message({
188
    caps: [capB]
189
  }))
190
191
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
192
    caps: [capB]
193
  }))
194
195
  const stateRoot = await hypervisor.createStateRoot(Infinity)
196
197
  t.deepEquals(stateRoot, expectedState, 'expected root!')
198
})
199
200
tape('response caps', async t => {
201
  t.plan(3)
202
  let message
203
  const expectedState = {
204
    '/': Buffer.from('fc935489953ed357f06171dd23439d83190b3a1b', 'hex')
205
  }
206
207
  const tree = new RadixTree({
208
    db: db
209
  })
210
211
  class testVMContainerA extends BaseContainer {
212
    onCreation (m) {
213
      message = new Message()
214
      message.responseCap = this.actor.mintCap()
215
      return this.actor.send(m.caps[0], message)
216
    }
217
218
    onMessage (m) {
219
      t.true(m, 'should recive a response message')
220
    }
221
  }
222
223
  class testVMContainerB extends BaseContainer {
224
    onMessage (m) {
225
      t.true(m === message, 'should recive a message')
226
    }
227
228
    static get typeId () {
229
      return 8
230
    }
231
  }
232
233
  const hypervisor = new Hypervisor(tree)
234
  hypervisor.registerContainer(testVMContainerA)
235
  hypervisor.registerContainer(testVMContainerB)
236
237
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
238
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
239
    caps: [capB]
240
  }))
241
242
  const stateRoot = await hypervisor.createStateRoot(Infinity)
243
244
  t.deepEquals(stateRoot, expectedState, 'expected root!')
245
})
246
247
tape('response caps for errors', async t => {
248
  t.plan(3)
249
  let message
250
  const expectedState = {
251
    '/': Buffer.from('fc935489953ed357f06171dd23439d83190b3a1b', 'hex')
252
  }
253
254
  const tree = new RadixTree({
255
    db: db
256
  })
257
258
  class testVMContainerA extends BaseContainer {
259
    onCreation (m) {
260
      message = new Message()
261
      message.responseCap = this.actor.mintCap()
262
      return this.actor.send(m.caps[0], message)
263
    }
264
265
    onMessage (m) {
266
      t.true(m.data.exceptionError instanceof Error, 'should recive a response message')
267
    }
268
  }
269
270
  class testVMContainerB extends BaseContainer {
271
    onMessage (m) {
272
      t.true(m === message, 'should recive a message')
273
      throw new Error('test error')
274
    }
275
276
    static get typeId () {
277
      return 8
278
    }
279
  }
280
281
  const hypervisor = new Hypervisor(tree)
282
  hypervisor.registerContainer(testVMContainerA)
283
  hypervisor.registerContainer(testVMContainerB)
284
285
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
286
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
287
    caps: [capB]
288
  }))
289
290
  const stateRoot = await hypervisor.createStateRoot(Infinity)
291
292
  t.deepEquals(stateRoot, expectedState, 'expected root!')
293
})
294
295
tape('actor creation', async t => {
296
  t.plan(2)
297
  let message
298
  const expectedState = {
299
    '/': Buffer.from('8e809b10d473ef4592dc5c1683e89bc7001e5e3e', 'hex')
300
  }
301
302
  const tree = new RadixTree({
303
    db: db
304
  })
305
306
  class testVMContainerA extends BaseContainer {
307
    onCreation (m) {
308
      message = new Message()
309
      const cap = this.actor.mintCap()
310
      message.caps.push(cap)
311
      return this.actor.createActor(testVMContainerB.typeId, message)
312
    }
313
314
    onMessage (m) {
315
      t.equals(m.data, 'test', 'should recive a response message')
316
    }
317
  }
318
319
  class testVMContainerB extends BaseContainer {
320
    onCreation (m) {
321
      const cap = m.caps[0]
322
      return this.actor.send(cap, new Message({data: 'test'}))
323
    }
324
325
    static get typeId () {
326
      return 8
327
    }
328
  }
329
330
  const hypervisor = new Hypervisor(tree)
331
  hypervisor.registerContainer(testVMContainerA)
332
  hypervisor.registerContainer(testVMContainerB)
333
334
  await hypervisor.createActor(testVMContainerA.typeId, new Message())
335
336
  const stateRoot = await hypervisor.createStateRoot(Infinity)
337
338
  t.deepEquals(stateRoot, expectedState, 'expected root!')
339
})
340
341
tape('simple message arbiter test', async t => {
342
  t.plan(4)
343
  const expectedState = {
344
    '/': Buffer.from('fc935489953ed357f06171dd23439d83190b3a1b', 'hex')
345
  }
346
347
  const tree = new RadixTree({
348
    db: db
349
  })
350
351
  class testVMContainerA extends BaseContainer {
352
    onCreation (m) {
353
      const message1 = new Message({
354
        data: 'first'
355
      })
356
      const message2 = new Message({
357
        data: 'second'
358
      })
359
      const message3 = new Message({
360
        data: 'third'
361
      })
362
      this.actor.send(m.caps[0], message1)
363
      this.actor.incrementTicks(1)
364
      this.actor.send(m.caps[0], message2)
365
      this.actor.incrementTicks(1)
366
      return this.actor.send(m.caps[0], message3)
367
    }
368
  }
369
370
  let recMsg = 0
371
372
  class testVMContainerB extends BaseContainer {
373
    onMessage (m) {
374
      if (recMsg === 0) {
375
        t.equal(m.data, 'first', 'should recive fist message')
376
      } else if (recMsg === 1) {
377
        t.equal(m.data, 'second', 'should recive second message')
378
      } else {
379
        t.equal(m.data, 'third', 'should recive third message')
380
      }
381
      recMsg++
382
    }
383
384
    static get typeId () {
385
      return 8
386
    }
387
  }
388
389
  const hypervisor = new Hypervisor(tree)
390
  hypervisor.registerContainer(testVMContainerA)
391
  hypervisor.registerContainer(testVMContainerB)
392
393
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
394
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
395
    caps: [capB]
396
  }))
397
398
  const stateRoot = await hypervisor.createStateRoot(Infinity)
399
400
  t.deepEquals(stateRoot, expectedState, 'expected root!')
401
})
402
403
tape('arbiter test for id comparision', async t => {
404
  t.plan(4)
405
  let message
406
  const expectedState = {
407
    '/': Buffer.from('0866fe6a6adaf28c51ce99ddfddd49c492e9ce48', 'hex')
408
  }
409
410
  const tree = new RadixTree({
411
    db: db
412
  })
413
414
  class testVMContainerA extends BaseContainer {
415
    onCreation (m) {
416
      message = new Message({
417
        data: m.data
418
      })
419
      this.actor.send(m.caps[0], message)
420
    }
421
  }
422
423
  let recMsg = 0
424
425
  class testVMContainerB extends BaseContainer {
426
    onMessage (m) {
427
      if (recMsg === 0) {
428
        t.equal(m.data, 'first', 'should recive fist message')
429
      } else if (recMsg === 1) {
430
        t.equal(m.data, 'second', 'should recive second message')
431
      } else {
432
        t.equal(m.data, 'third', 'should recive third message')
433
      }
434
      recMsg++
435
436
      return new Promise((resolve, reject) => {
437
        setTimeout(resolve, 200)
438
      })
439
    }
440
441
    static get typeId () {
442
      return 8
443
    }
444
  }
445
446
  const hypervisor = new Hypervisor(tree)
447
  hypervisor.registerContainer(testVMContainerA)
448
  hypervisor.registerContainer(testVMContainerB)
449
450
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
451
  hypervisor.send(capB, new Message({
452
    data: 'first'
453
  }))
454
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
455
    caps: [capB],
456
    data: 'second'
457
  }))
458
459
  await hypervisor.createActor(testVMContainerA.typeId, new Message({
460
    caps: [capB],
461
    data: 'third'
462
  }))
463
464
  const stateRoot = await hypervisor.createStateRoot(Infinity)
465
466
  t.deepEquals(stateRoot, expectedState, 'expected root!')
467
})
468
469
tape('basic tagged caps', async t => {
470
  t.plan(4)
471
  const expectedState = {
472
    '/': Buffer.from('ef403643f292108fe9edc1700d80a7bf2402e7a0', 'hex')
473
  }
474
475
  const tree = new RadixTree({
476
    db: db
477
  })
478
479
  class testVMContainerA extends BaseContainer {
480
    async onMessage (m) {
481
      t.true(m, 'should recive first message')
482
      const rCap = this.actor.mintCap(1)
483
      const message = new Message()
484
      message.responseCap = rCap
485
      await this.actor.send(m.caps[0], message)
486
      const rMessage = await this.actor.inbox.nextTaggedMessage([1], 44)
487
      t.true(rMessage, 'should recive a response message')
488
    }
489
  }
490
491
  class testVMContainerB extends BaseContainer {
492
    onMessage (m) {
493
      t.true(m, 'should recive a message')
494
    }
495
496
    static get typeId () {
497
      return 8
498
    }
499
  }
500
501
  const hypervisor = new Hypervisor(tree)
502
  hypervisor.registerContainer(testVMContainerA)
503
  hypervisor.registerContainer(testVMContainerB)
504
505
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
506
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
507
508
  await hypervisor.send(capA, new Message({caps: [capB]}))
509
510
  const stateRoot = await hypervisor.createStateRoot(Infinity)
511
512
  t.deepEquals(stateRoot, expectedState, 'expected root!')
513
})
514
515
tape('trying to listen for caps more then once', async t => {
516
  t.plan(4)
517
  const expectedState = {
518
    '/': Buffer.from('ef403643f292108fe9edc1700d80a7bf2402e7a0', 'hex')
519
  }
520
521
  const tree = new RadixTree({
522
    db: db
523
  })
524
525
  class testVMContainerA extends BaseContainer {
526
    async onMessage (m) {
527
      t.true(m, 'should recive first message')
528
      const rCap = this.actor.mintCap(1)
529
      const message = new Message({data: 'first'})
530
      message.responseCap = rCap
531
      await this.actor.send(m.caps[0], message)
532
      const promise = this.actor.inbox.nextTaggedMessage([1], 44)
533
      try {
534
        await this.actor.inbox.nextTaggedMessage([1], 44)
535
      } catch (e) {
536
        t.true(e, 'should error if waiting twice')
537
      }
538
      return promise
539
    }
540
  }
541
542
  class testVMContainerB extends BaseContainer {
543
    onMessage (m) {
544
      t.true(m, 'should recive a message')
545
    }
546
547
    static get typeId () {
548
      return 8
549
    }
550
  }
551
552
  const hypervisor = new Hypervisor(tree)
553
  hypervisor.registerContainer(testVMContainerA)
554
  hypervisor.registerContainer(testVMContainerB)
555
556
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
557
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
558
559
  await hypervisor.send(capA, new Message({caps: [capB]}))
560
561
  const stateRoot = await hypervisor.createStateRoot(Infinity)
562
563
  t.deepEquals(stateRoot, expectedState, 'expected root!')
564
})
565
566
tape('multple messages to restore on waiting for tags', async t => {
567
  t.plan(6)
568
  const expectedState = {
569
    '/': Buffer.from('c2bbd78ee38ecf417f857451bdb06cdba1345b22', 'hex')
570
  }
571
572
  const tree = new RadixTree({
573
    db: db
574
  })
575
576
  class testVMContainerA extends BaseContainer {
577
    async onMessage (m) {
578
      t.true(m, 'should recive first message')
579
      if (m.caps.length) {
580
        const cap1 = this.actor.mintCap(1)
581
        const cap2 = this.actor.mintCap(2)
582
        const message1 = new Message({
583
          data: 'first'
584
        })
585
        const message2 = new Message({
586
          data: 'second'
587
        })
588
        message1.caps.push(cap1)
589
        message2.caps.push(cap2)
590
        await Promise.all([
591
          this.actor.send(m.caps[0], message1),
592
          this.actor.send(m.caps[1], message2)
593
        ])
594
        const rMessage = await this.actor.inbox.nextTaggedMessage([1, 2], 44)
595
        t.true(rMessage, 'should recive a response message')
596
      }
597
    }
598
  }
599
600
  class testVMContainerB extends BaseContainer {
601
    async onMessage (m) {
602
      t.true(m, 'should recive a message')
603
      const cap = m.caps[0]
604
      this.actor.incrementTicks(1)
605
      await this.actor.send(cap, new Message({data: m.data}))
606
607
      return new Promise((resolve, reject) => {
608
        setTimeout(resolve, 200)
609
      })
610
    }
611
612
    static get typeId () {
613
      return 8
614
    }
615
  }
616
617
  const hypervisor = new Hypervisor(tree)
618
  hypervisor.registerContainer(testVMContainerA)
619
  hypervisor.registerContainer(testVMContainerB)
620
621
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
622
  let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
623
  let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
624
625
  await hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
626
627
  const stateRoot = await hypervisor.createStateRoot(Infinity)
628
629
  t.deepEquals(stateRoot, expectedState, 'expected root!')
630
})
631
632
tape('multple messages to backup on waiting for tags', async t => {
633
  t.plan(6)
634
  const expectedState = {
635
    '/': Buffer.from('c2bbd78ee38ecf417f857451bdb06cdba1345b22', 'hex')
636
  }
637
638
  const tree = new RadixTree({
639
    db: db
640
  })
641
642
  class testVMContainerA extends BaseContainer {
643
    async onMessage (m) {
644
      t.true(m, 'should recive first message')
645
      if (m.caps.length) {
646
        const cap1 = this.actor.mintCap(1)
647
        const cap2 = this.actor.mintCap(2)
648
        const message1 = new Message({
649
          data: 'first'
650
        })
651
        const message2 = new Message({
652
          data: 'second'
653
        })
654
        message1.caps.push(cap1)
655
        message2.caps.push(cap2)
656
        await this.actor.send(m.caps[0], message1)
657
        await this.actor.send(m.caps[1], message2)
658
        const rMessage = await this.actor.inbox.nextTaggedMessage([1, 2], 44)
659
        t.true(rMessage, 'should recive a response message')
660
      }
661
    }
662
  }
663
664
  class testVMContainerB extends BaseContainer {
665
    async onMessage (m) {
666
      t.true(m, 'should recive a message')
667
      const cap = m.caps[0]
668
      this.actor.incrementTicks(1)
669
      await this.actor.send(cap, new Message({data: m.data}))
670
671
      return new Promise((resolve, reject) => {
672
        setTimeout(resolve, 200)
673
      })
674
    }
675
676
    static get typeId () {
677
      return 8
678
    }
679
  }
680
681
  const hypervisor = new Hypervisor(tree)
682
  hypervisor.registerContainer(testVMContainerA)
683
  hypervisor.registerContainer(testVMContainerB)
684
685
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
686
  let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
687
  let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
688
689
  await hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
690
691
  const stateRoot = await hypervisor.createStateRoot(Infinity)
692
693
  t.deepEquals(stateRoot, expectedState, 'expected root!')
694
})
695
696
tape('multple messages, but single tag', async t => {
697
  t.plan(6)
698
  const expectedState = {
699
    '/': Buffer.from('c2bbd78ee38ecf417f857451bdb06cdba1345b22', 'hex')
700
  }
701
702
  const tree = new RadixTree({
703
    db: db
704
  })
705
706
  class testVMContainerA extends BaseContainer {
707
    async onMessage (m) {
708
      t.true(m, 'should recive first message')
709
      if (m.caps.length) {
710
        const cap1 = this.actor.mintCap(1)
711
        const cap2 = this.actor.mintCap(2)
712
        const message1 = new Message({
713
          data: 'first'
714
        })
715
        const message2 = new Message({
716
          data: 'second'
717
        })
718
        message1.caps.push(cap1)
719
        message2.caps.push(cap2)
720
        await this.actor.send(m.caps[0], message1)
721
        await this.actor.send(m.caps[1], message2)
722
        const rMessage = await this.actor.inbox.nextTaggedMessage([2], 44)
723
        t.true(rMessage, 'should recive a response message')
724
      }
725
    }
726
  }
727
728
  class testVMContainerB extends BaseContainer {
729
    async onMessage (m) {
730
      t.true(m, 'should recive a message')
731
      const cap = m.caps[0]
732
      this.actor.incrementTicks(1)
733
      await this.actor.send(cap, new Message({data: m.data}))
734
735
      return new Promise((resolve, reject) => {
736
        setTimeout(resolve, 200)
737
      })
738
    }
739
740
    static get typeId () {
741
      return 8
742
    }
743
  }
744
745
  const hypervisor = new Hypervisor(tree)
746
  hypervisor.registerContainer(testVMContainerA)
747
  hypervisor.registerContainer(testVMContainerB)
748
749
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
750
  let capB1 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
751
  let capB2 = await hypervisor.createActor(testVMContainerB.typeId, new Message())
752
753
  await hypervisor.send(capA, new Message({caps: [capB1, capB2]}))
754
755
  const stateRoot = await hypervisor.createStateRoot(Infinity)
756
757
  t.deepEquals(stateRoot, expectedState, 'expected root!')
758
})
759
760
tape('deadlock test', async t => {
761
  t.plan(7)
762
  const expectedState = {
763
    '/': Buffer.from('2e8658dc2f616599b4fa622318b86ad6ed809db0', 'hex')
764
  }
765
766
  const tree = new RadixTree({
767
    db: db
768
  })
769
770
  class testVMContainerA extends BaseContainer {
771
    async onMessage (m) {
772
      t.true(m, 'should recive first message 1')
773
      const rMessage = await this.actor.inbox.nextTaggedMessage([1], 50)
774
      t.equals(rMessage, undefined, 'should recive a response message 1')
775
    }
776
  }
777
778
  class testVMContainerB extends BaseContainer {
779
    async onMessage (m) {
780
      t.true(m, 'should recive first message 2')
781
      this.actor.incrementTicks(47)
782
      const rMessage = await this.actor.inbox.nextTaggedMessage([1], 1)
783
      t.equals(rMessage, undefined, 'should recive a response message 2')
784
    }
785
786
    static get typeId () {
787
      return 8
788
    }
789
  }
790
791
  class testVMContainerC extends BaseContainer {
792
    async onMessage (m) {
793
      t.true(m, 'should recive first message 3')
794
      this.actor.incrementTicks(45)
795
      const rMessage = await this.actor.inbox.nextTaggedMessage([1], 1)
796
      t.equals(rMessage, undefined, 'should recive a response message 3')
797
    }
798
799
    static get typeId () {
800
      return 7
801
    }
802
  }
803
804
  const hypervisor = new Hypervisor(tree)
805
  hypervisor.registerContainer(testVMContainerA)
806
  hypervisor.registerContainer(testVMContainerB)
807
  hypervisor.registerContainer(testVMContainerC)
808
809
  let capA = await hypervisor.createActor(testVMContainerA.typeId, new Message())
810
  let capB = await hypervisor.createActor(testVMContainerB.typeId, new Message())
811
  let capC = await hypervisor.createActor(testVMContainerC.typeId, new Message())
812
813
  await Promise.all([
814
    hypervisor.send(capA, new Message()),
815
    hypervisor.send(capB, new Message()),
816
    hypervisor.send(capC, new Message())
817
  ])
818
  const stateRoot = await hypervisor.createStateRoot(Infinity)
819
  t.deepEquals(stateRoot, expectedState, 'expected root!')
820
})
821