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

1from . import bindgen 

2import math 

3from wasmtime import Store 

4 

5module = """ 

6 (component 

7 (import "host" (instance $i 

8 (export "roundtrip-u8" (func (param "a" u8) (result u8))) 

9 (export "roundtrip-s8" (func (param "a" s8) (result s8))) 

10 (export "roundtrip-u16" (func (param "a" u16) (result u16))) 

11 (export "roundtrip-s16" (func (param "a" s16) (result s16))) 

12 (export "roundtrip-u32" (func (param "a" u32) (result u32))) 

13 (export "roundtrip-s32" (func (param "a" s32) (result s32))) 

14 (export "roundtrip-u64" (func (param "a" u64) (result u64))) 

15 (export "roundtrip-s64" (func (param "a" s64) (result s64))) 

16 (export "roundtrip-float32" (func (param "a" float32) (result float32))) 

17 (export "roundtrip-float64" (func (param "a" float64) (result float64))) 

18 (export "roundtrip-char" (func (param "a" char) (result char))) 

19 (export "roundtrip-bool" (func (param "a" bool) (result bool))) 

20 )) 

21 (core module $m 

22 (import "" "roundtrip-u8" (func $u8 (param i32) (result i32))) 

23 (import "" "roundtrip-s8" (func $s8 (param i32) (result i32))) 

24 (import "" "roundtrip-u16" (func $u16 (param i32) (result i32))) 

25 (import "" "roundtrip-s16" (func $s16 (param i32) (result i32))) 

26 (import "" "roundtrip-u32" (func $u32 (param i32) (result i32))) 

27 (import "" "roundtrip-s32" (func $s32 (param i32) (result i32))) 

28 (import "" "roundtrip-u64" (func $u64 (param i64) (result i64))) 

29 (import "" "roundtrip-s64" (func $s64 (param i64) (result i64))) 

30 

31 (import "" "roundtrip-float32" (func $float32 (param f32) (result f32))) 

32 (import "" "roundtrip-float64" (func $float64 (param f64) (result f64))) 

33 

34 (import "" "roundtrip-char" (func $char (param i32) (result i32))) 

35 (import "" "roundtrip-bool" (func $bool (param i32) (result i32))) 

36 

37 (func (export "roundtrip-u8") (param i32) (result i32) 

38 local.get 0 call $u8) 

39 (func (export "roundtrip-s8") (param i32) (result i32) 

40 local.get 0 call $s8) 

41 (func (export "roundtrip-u16") (param i32) (result i32) 

42 local.get 0 call $u16) 

43 (func (export "roundtrip-s16") (param i32) (result i32) 

44 local.get 0 call $s16) 

45 (func (export "roundtrip-u32") (param i32) (result i32) 

46 local.get 0 call $u32) 

47 (func (export "roundtrip-s32") (param i32) (result i32) 

48 local.get 0 call $s32) 

49 (func (export "roundtrip-u64") (param i64) (result i64) 

50 local.get 0 call $u64) 

51 (func (export "roundtrip-s64") (param i64) (result i64) 

52 local.get 0 call $s64) 

53 

54 (func (export "roundtrip-float32") (param f32) (result f32) 

55 local.get 0 call $float32) 

56 (func (export "roundtrip-float64") (param f64) (result f64) 

57 local.get 0 call $float64) 

58 

59 (func (export "roundtrip-char") (param i32) (result i32) 

60 local.get 0 call $char) 

61 (func (export "roundtrip-bool") (param i32) (result i32) 

62 local.get 0 call $bool) 

63 ) 

64 (core func $u8 (canon lower (func $i "roundtrip-u8"))) 

65 (core func $s8 (canon lower (func $i "roundtrip-s8"))) 

66 (core func $u16 (canon lower (func $i "roundtrip-u16"))) 

67 (core func $s16 (canon lower (func $i "roundtrip-s16"))) 

68 (core func $u32 (canon lower (func $i "roundtrip-u32"))) 

69 (core func $s32 (canon lower (func $i "roundtrip-s32"))) 

70 (core func $u64 (canon lower (func $i "roundtrip-u64"))) 

71 (core func $s64 (canon lower (func $i "roundtrip-s64"))) 

72 (core func $float32 (canon lower (func $i "roundtrip-float32"))) 

73 (core func $float64 (canon lower (func $i "roundtrip-float64"))) 

74 (core func $char (canon lower (func $i "roundtrip-char"))) 

75 (core func $bool (canon lower (func $i "roundtrip-bool"))) 

76 

77 (core instance $i (instantiate $m 

78 (with "" (instance 

79 (export "roundtrip-u8" (func $u8)) 

80 (export "roundtrip-s8" (func $s8)) 

81 (export "roundtrip-u16" (func $u16)) 

82 (export "roundtrip-s16" (func $s16)) 

83 (export "roundtrip-u32" (func $u32)) 

84 (export "roundtrip-s32" (func $s32)) 

85 (export "roundtrip-u64" (func $u64)) 

86 (export "roundtrip-s64" (func $s64)) 

87 (export "roundtrip-float32" (func $float32)) 

88 (export "roundtrip-float64" (func $float64)) 

89 (export "roundtrip-char" (func $char)) 

90 (export "roundtrip-bool" (func $bool)) 

91 )) 

92 )) 

93 

94 (func (export "roundtrip-u8") (param "a" u8) (result u8) 

95 (canon lift (core func $i "roundtrip-u8"))) 

96 (func (export "roundtrip-s8") (param "a" s8) (result s8) 

97 (canon lift (core func $i "roundtrip-s8"))) 

98 (func (export "roundtrip-u16") (param "a" u16) (result u16) 

99 (canon lift (core func $i "roundtrip-u16"))) 

100 (func (export "roundtrip-s16") (param "a" s16) (result s16) 

101 (canon lift (core func $i "roundtrip-s16"))) 

102 (func (export "roundtrip-u32") (param "a" u32) (result u32) 

103 (canon lift (core func $i "roundtrip-u32"))) 

104 (func (export "roundtrip-s32") (param "a" s32) (result s32) 

105 (canon lift (core func $i "roundtrip-s32"))) 

106 (func (export "roundtrip-u64") (param "a" u64) (result u64) 

107 (canon lift (core func $i "roundtrip-u64"))) 

108 (func (export "roundtrip-s64") (param "a" s64) (result s64) 

109 (canon lift (core func $i "roundtrip-s64"))) 

110 (func (export "roundtrip-float32") (param "a" float32) (result float32) 

111 (canon lift (core func $i "roundtrip-float32"))) 

112 (func (export "roundtrip-float64") (param "a" float64) (result float64) 

113 (canon lift (core func $i "roundtrip-float64"))) 

114 (func (export "roundtrip-char") (param "a" char) (result char) 

115 (canon lift (core func $i "roundtrip-char"))) 

116 (func (export "roundtrip-bool") (param "a" bool) (result bool) 

117 (canon lift (core func $i "roundtrip-bool"))) 

118 ) 

119""" 

120bindgen('scalars', module) 

121 

122from .generated.scalars import Root, RootImports, imports 

123 

124 

125class Host(imports.HostHost): 

126 def roundtrip_u8(self, val: int) -> int: 

127 assert val >= 0 

128 assert val <= (1 << 8) - 1 

129 return val 

130 

131 def roundtrip_s8(self, val: int) -> int: 

132 assert val >= -(1 << (8 - 1)) 

133 assert val <= (1 << (8 - 1)) - 1 

134 return val 

135 

136 def roundtrip_u16(self, val: int) -> int: 

137 assert val >= 0 

138 assert val <= (1 << 16) - 1 

139 return val 

140 

141 def roundtrip_s16(self, val: int) -> int: 

142 assert val >= -(1 << (16 - 1)) 

143 assert val <= (1 << (16 - 1)) - 1 

144 return val 

145 

146 def roundtrip_u32(self, val: int) -> int: 

147 assert val >= 0 

148 assert val <= (1 << 32) - 1 

149 return val 

150 

151 def roundtrip_s32(self, val: int) -> int: 

152 assert val >= -(1 << (32 - 1)) 

153 assert val <= (1 << (32 - 1)) - 1 

154 return val 

155 

156 def roundtrip_u64(self, val: int) -> int: 

157 assert val >= 0 

158 assert val <= (1 << 64) - 1 

159 return val 

160 

161 def roundtrip_s64(self, val: int) -> int: 

162 assert val >= -(1 << (64 - 1)) 

163 assert val <= (1 << (64 - 1)) - 1 

164 return val 

165 

166 def roundtrip_float32(self, a: float) -> float: 

167 return a 

168 

169 def roundtrip_float64(self, a: float) -> float: 

170 return a 

171 

172 def roundtrip_char(self, a: str) -> str: 

173 return a 

174 

175 def roundtrip_bool(self, a: bool) -> bool: 

176 return a 

177 

178 

179def test_bindings(): 

180 store = Store() 

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

182 

183 assert bindings.roundtrip_u8(store, 0) == 0 

184 assert bindings.roundtrip_u8(store, (1 << 8) - 1) == (1 << 8) - 1 

185 assert bindings.roundtrip_u16(store, 0) == 0 

186 assert bindings.roundtrip_u16(store, (1 << 16) - 1) == (1 << 16) - 1 

187 assert bindings.roundtrip_u32(store, 0) == 0 

188 assert bindings.roundtrip_u32(store, (1 << 32) - 1) == (1 << 32) - 1 

189 assert bindings.roundtrip_u64(store, 0) == 0 

190 assert bindings.roundtrip_u64(store, (1 << 64) - 1) == (1 << 64) - 1 

191 

192 assert bindings.roundtrip_s8(store, 0) == 0 

193 assert bindings.roundtrip_s8(store, (1 << (8 - 1)) - 1) == (1 << (8 - 1)) - 1 

194 assert bindings.roundtrip_s8(store, -(1 << (8 - 1))) == -(1 << (8 - 1)) 

195 assert bindings.roundtrip_s16(store, 0) == 0 

196 assert bindings.roundtrip_s16(store, (1 << (16 - 1)) - 1) == (1 << (16 - 1)) - 1 

197 assert bindings.roundtrip_s16(store, -(1 << (16 - 1))) == -(1 << (16 - 1)) 

198 assert bindings.roundtrip_s32(store, 0) == 0 

199 assert bindings.roundtrip_s32(store, (1 << (32 - 1)) - 1) == (1 << (32 - 1)) - 1 

200 assert bindings.roundtrip_s32(store, -(1 << (32 - 1))) == -(1 << (32 - 1)) 

201 assert bindings.roundtrip_s64(store, 0) == 0 

202 assert bindings.roundtrip_s64(store, (1 << (64 - 1)) - 1) == (1 << (64 - 1)) - 1 

203 assert bindings.roundtrip_s64(store, -(1 << (64 - 1))) == -(1 << (64 - 1)) 

204 

205 inf = float('inf') 

206 assert bindings.roundtrip_float32(store, 1.0) == 1.0 

207 assert bindings.roundtrip_float32(store, inf) == inf 

208 assert bindings.roundtrip_float32(store, -inf) == -inf 

209 assert math.isnan(bindings.roundtrip_float32(store, float('nan'))) 

210 

211 assert bindings.roundtrip_float64(store, 1.0) == 1.0 

212 assert bindings.roundtrip_float64(store, inf) == inf 

213 assert bindings.roundtrip_float64(store, -inf) == -inf 

214 assert math.isnan(bindings.roundtrip_float64(store, float('nan'))) 

215 

216 assert bindings.roundtrip_char(store, 'a') == 'a' 

217 assert bindings.roundtrip_char(store, ' ') == ' ' 

218 assert bindings.roundtrip_char(store, '🚩') == '🚩' 

219 

220 assert bindings.roundtrip_bool(store, True) 

221 assert not bindings.roundtrip_bool(store, False)