Coverage for tests/codegen/test_records.py: 100%

1from . import bindgen 

2from typing import Tuple 

3from wasmtime import Store 

4 

5module = """ 

6 (component 

7 (type $tuple (tuple u8 u32)) 

8 

9 (type $flag1 (flags "a" "b")) 

10 (type $flag2 (flags "a" "b" "c")) 

11 (type $flag8 (flags "a1" "a2" "a3" "a4" "a5" "a6" "a7" "a8")) 

12 (type $flag16 (flags 

13 "a1" "a2" "a3" "a4" "a5" "a6" "a7" "a8" "a9" "a10" "a11" "a12" "a13" 

14 "a14" "a15" "a16" 

15 )) 

16 (type $flag32 (flags 

17 "a1" "a2" "a3" "a4" "a5" "a6" "a7" "a8" "a9" "a10" "a11" "a12" "a13" 

18 "a14" "a15" "a16" "a17" "a18" "a19" "a20" "a21" "a22" "a23" "a24" 

19 "a25" "a26" "a27" "a28" "a29" "a30" "a31" "a32" 

20 )) 

21 

22 (type $r1 (record (field "a" u8) (field "b" $flag1))) 

23 

24 (import "host" (instance $i 

25 (export "multiple-results" (func (result (tuple u8 u16)))) 

26 (export "swap" (func (param "a" $tuple) (result $tuple))) 

27 

28 (export $f1 "flag1" (type (eq $flag1))) 

29 (export $f2 "flag2" (type (eq $flag2))) 

30 (export $f8 "flag8" (type (eq $flag8))) 

31 (export $f16 "flag16" (type (eq $flag16))) 

32 (export $f32 "flag32" (type (eq $flag32))) 

33 

34 (export "roundtrip-flag1" (func (param "a" $f1) (result $f1))) 

35 (export "roundtrip-flag2" (func (param "a" $f2) (result $f2))) 

36 (export "roundtrip-flag8" (func (param "a" $f8) (result $f8))) 

37 (export "roundtrip-flag16" (func (param "a" $f16) (result $f16))) 

38 (export "roundtrip-flag32" (func (param "a" $f32) (result $f32))) 

39 

40 (type $r1 (record (field "a" u8) (field "b" $f1))) 

41 (export $r1' "r1" (type (eq $r1))) 

42 (export "roundtrip-r1" (func (param "a" $r1') (result $r1'))) 

43 )) 

44 

45 (core module $libc 

46 (memory (export "mem") 1) 

47 ) 

48 (core instance $libc (instantiate $libc)) 

49 

50 (core func $multi (canon lower (func $i "multiple-results") (memory $libc "mem"))) 

51 (core func $swap (canon lower (func $i "swap") (memory $libc "mem"))) 

52 (core func $r-flag1 (canon lower (func $i "roundtrip-flag1"))) 

53 (core func $r-flag2 (canon lower (func $i "roundtrip-flag2"))) 

54 (core func $r-flag8 (canon lower (func $i "roundtrip-flag8"))) 

55 (core func $r-flag16 (canon lower (func $i "roundtrip-flag16"))) 

56 (core func $r-flag32 (canon lower (func $i "roundtrip-flag32"))) 

57 (core func $r-r1 (canon lower (func $i "roundtrip-r1") (memory $libc "mem"))) 

58 

59 (core module $m 

60 (import "" "r-flag1" (func $r-flag1 (param i32) (result i32))) 

61 (import "" "r-flag2" (func $r-flag2 (param i32) (result i32))) 

62 (import "" "r-flag8" (func $r-flag8 (param i32) (result i32))) 

63 (import "" "r-flag16" (func $r-flag16 (param i32) (result i32))) 

64 (import "" "r-flag32" (func $r-flag32 (param i32) (result i32))) 

65 (import "" "multi" (func $multi (param i32))) 

66 (import "" "swap" (func $swap (param i32 i32 i32))) 

67 (import "" "r-r1" (func $r-r1 (param i32 i32 i32))) 

68 

69 (import "libc" "mem" (memory 1)) 

70 

71 (func (export "multi") (result i32) 

72 (call $multi (i32.const 100)) 

73 i32.const 100) 

74 

75 (func (export "swap") (param i32 i32) (result i32) 

76 (call $swap (local.get 0) (local.get 1) (i32.const 100)) 

77 i32.const 100) 

78 

79 (func (export "r-flag1") (param i32) (result i32) 

80 (call $r-flag1 (local.get 0))) 

81 (func (export "r-flag2") (param i32) (result i32) 

82 (call $r-flag2 (local.get 0))) 

83 (func (export "r-flag8") (param i32) (result i32) 

84 (call $r-flag8 (local.get 0))) 

85 (func (export "r-flag16") (param i32) (result i32) 

86 (call $r-flag16 (local.get 0))) 

87 (func (export "r-flag32") (param i32) (result i32) 

88 (call $r-flag32 (local.get 0))) 

89 (func (export "r-r1") (param i32 i32) (result i32) 

90 (call $r-r1 (local.get 0) (local.get 1) (i32.const 100)) 

91 i32.const 100) 

92 ) 

93 

94 (core instance $i (instantiate $m 

95 (with "libc" (instance $libc)) 

96 (with "" (instance 

97 (export "multi" (func $multi)) 

98 (export "swap" (func $swap)) 

99 (export "r-flag1" (func $r-flag1)) 

100 (export "r-flag2" (func $r-flag2)) 

101 (export "r-flag8" (func $r-flag8)) 

102 (export "r-flag16" (func $r-flag16)) 

103 (export "r-flag32" (func $r-flag32)) 

104 (export "r-r1" (func $r-r1)) 

105 )) 

106 )) 

107 

108 (func $multiple-results (result (tuple u8 u16)) 

109 (canon lift (core func $i "multi") (memory $libc "mem"))) 

110 (func $swap (param "a" $tuple) (result $tuple) 

111 (canon lift (core func $i "swap") (memory $libc "mem"))) 

112 (func $roundtrip-flag1 (param "a" $flag1) (result $flag1) 

113 (canon lift (core func $i "r-flag1"))) 

114 (func $roundtrip-flag2 (param "a" $flag2) (result $flag2) 

115 (canon lift (core func $i "r-flag2"))) 

116 (func $roundtrip-flag8 (param "a" $flag8) (result $flag8) 

117 (canon lift (core func $i "r-flag8"))) 

118 (func $roundtrip-flag16 (param "a" $flag16) (result $flag16) 

119 (canon lift (core func $i "r-flag16"))) 

120 (func $roundtrip-flag32 (param "a" $flag32) (result $flag32) 

121 (canon lift (core func $i "r-flag32"))) 

122 (func $roundtrip-r1 (param "a" $r1) (result $r1) 

123 (canon lift (core func $i "r-r1") (memory $libc "mem"))) 

124 

125 (instance (export "e") 

126 (export "flag1" (type $flag1)) 

127 (export "flag2" (type $flag2)) 

128 (export "flag8" (type $flag8)) 

129 (export "flag16" (type $flag16)) 

130 (export "flag32" (type $flag32)) 

131 (export "r1" (type $r1)) 

132 

133 (export "multiple-results" (func $multiple-results)) 

134 (export "swap" (func $swap)) 

135 (export "roundtrip-flag1" (func $roundtrip-flag1)) 

136 (export "roundtrip-flag2" (func $roundtrip-flag2)) 

137 (export "roundtrip-flag8" (func $roundtrip-flag8)) 

138 (export "roundtrip-flag16" (func $roundtrip-flag16)) 

139 (export "roundtrip-flag32" (func $roundtrip-flag32)) 

140 (export "roundtrip-r1" (func $roundtrip-r1)) 

141 ) 

142 ) 

143""" 

144bindgen('records', module) 

145 

146from .generated.records import Root, RootImports, imports 

147from .generated.records.exports.e import Flag1, Flag2, Flag8, Flag16, Flag32, R1 

148from .generated.records.imports import host 

149 

150 

151class Host(imports.HostHost): 

152 def multiple_results(self) -> Tuple[int, int]: 

153 return 1, 2 

154 

155 def swap(self, tuple: Tuple[int, int]) -> Tuple[int, int]: 

156 a, b = tuple 

157 return b, a 

158 

159 def roundtrip_flag1(self, f: host.Flag1) -> host.Flag1: 

160 return f 

161 

162 def roundtrip_flag2(self, f: host.Flag2) -> host.Flag2: 

163 return f 

164 

165 def roundtrip_flag8(self, f: host.Flag8) -> host.Flag8: 

166 return f 

167 

168 def roundtrip_flag16(self, f: host.Flag16) -> host.Flag16: 

169 return f 

170 

171 def roundtrip_flag32(self, f: host.Flag32) -> host.Flag32: 

172 return f 

173 

174 def roundtrip_r1(self, f: host.R1) -> host.R1: 

175 return f 

176 

177 

178def test_bindings(): 

179 store = Store() 

180 bindings = Root(store, RootImports(host=Host())) 

181 

182 assert bindings.e().multiple_results(store) == (1, 2) 

183 assert bindings.e().swap(store, (3, 4)) == (4, 3) 

184 

185 assert bindings.e().roundtrip_flag1(store, Flag1(0)) == Flag1(0) 

186 for f1 in Flag1: 

187 assert bindings.e().roundtrip_flag1(store, f1) == f1 

188 assert bindings.e().roundtrip_flag2(store, Flag2(0)) == Flag2(0) 

189 for f2 in Flag2: 

190 assert bindings.e().roundtrip_flag2(store, f2) == f2 

191 assert bindings.e().roundtrip_flag8(store, Flag8(0)) == Flag8(0) 

192 for f8 in Flag8: 

193 assert bindings.e().roundtrip_flag8(store, f8) == f8 

194 assert bindings.e().roundtrip_flag16(store, Flag16(0)) == Flag16(0) 

195 for f16 in Flag16: 

196 assert bindings.e().roundtrip_flag16(store, f16) == f16 

197 assert bindings.e().roundtrip_flag32(store, Flag32(0)) == Flag32(0) 

198 for f32 in Flag32: 

199 assert bindings.e().roundtrip_flag32(store, f32) == f32 

200 

201 r = bindings.e().roundtrip_r1(store, R1(8, Flag1(0))) 

202 assert r.a == 8 

203 assert r.b == Flag1(0) 

204 

205 r = bindings.e().roundtrip_r1(store, R1(a=100, b=Flag1.A | Flag1.B)) 

206 assert r.a == 100 

207 assert r.b == Flag1.A | Flag1.B