wasmtime-go/store_test.go at main · suborbital/wasmtime-go · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package wasmtime

import "testing"

func TestStore(t *testing.T) {
	engine := NewEngine()
	NewStore(engine)
}

func TestInterruptHandle(t *testing.T) {
	store := NewStore(NewEngine())
	handle, err := store.InterruptHandle()
	if handle != nil {
		panic("expected nil handle")
	}
	if err == nil {
		panic("expected an error")
	}

	config := NewConfig()
	config.SetInterruptable(true)
	store = NewStore(NewEngineWithConfig(config))
	handle, err = store.InterruptHandle()
	if err != nil {
		panic(err)
	}
	handle.Interrupt()
}

func TestInterruptWasm(t *testing.T) {
	config := NewConfig()
	config.SetInterruptable(true)
	store := NewStore(NewEngineWithConfig(config))
	handle, err := store.InterruptHandle()
	if err != nil {
		panic(err)
	}
	wasm, err := Wat2Wasm(`
	  (import "" "" (func))
	  (func
	    call 0
	    (loop br 0))
	  (start 1)
	`)
	if err != nil {
		panic(err)
	}
	module, err := NewModule(store.Engine, wasm)
	if err != nil {
		panic(err)
	}
	f := WrapFunc(store, func() {
		handle.Interrupt()
	})
	instance, err := NewInstance(store, module, []AsExtern{f})
	if instance != nil {
		panic("expected nil instance")
	}
	if err == nil {
		panic("expected an error")
	}
	trap := err.(*Trap)
	if trap == nil {
		panic("expected a trap")
	}
}

func TestFuelConsumed(t *testing.T) {
	engine := NewEngine()
	store := NewStore(engine)

	fuel, enable := store.FuelConsumed()
	if enable != false {
		t.Fatal("expected not enable")
	}
	if fuel != 0 {
		t.Fatalf("fuel is %d, not zero", fuel)
	}
}

func TestAddFuel(t *testing.T) {
	config := NewConfig()
	config.SetConsumeFuel(true)
	engine := NewEngineWithConfig(config)
	store := NewStore(engine)

	fuel, enable := store.FuelConsumed()
	if enable != true {
		t.Fatal("expected enabled")
	}
	if fuel != 0 {
		t.Fatalf("fuel is %d, not zero", fuel)
	}

	const add_fuel = 3
	if err := store.AddFuel(add_fuel); err != nil {
		t.Fatal("expected no error")
	}
}

func TestConsumeFuel(t *testing.T) {
	config := NewConfig()
	config.SetConsumeFuel(true)
	engine := NewEngineWithConfig(config)
	store := NewStore(engine)

	fuel, enable := store.FuelConsumed()
	if enable != true {
		t.Fatal("expected enabled")
	}
	if fuel != 0 {
		t.Fatalf("fuel is %d, not zero", fuel)
	}

	const add_fuel = 3
	if err := store.AddFuel(add_fuel); err != nil {
		t.Fatal("expected no error")
	}

	consume_fuel := uint64(1)
	remaining, err := store.ConsumeFuel(consume_fuel)
	if err != nil {
		t.Fatal("expected no error")
	}
	if remaining != (add_fuel - consume_fuel) {
		t.Fatalf("expected %d, but %d", add_fuel-consume_fuel, remaining)
	}
}