1 #![cfg(arc_try_new)]
2 
3 use wasmtime::{Config, Engine, Func, FuncType, Linker, Module, Result, Store, Val, ValType};
4 use wasmtime_fuzzing::oom::OomTest;
5 
6 #[test]
func_new() -> Result<()>7 fn func_new() -> Result<()> {
8     let mut config = Config::new();
9     config.enable_compiler(false);
10     config.concurrency_support(false);
11     let engine = Engine::new(&config)?;
12 
13     OomTest::new().test(|| {
14         let mut store = Store::try_new(&engine, ())?;
15         let _func = Func::try_wrap(&mut store, |x: i32| x * 2)?;
16         Ok(())
17     })
18 }
19 
20 #[test]
func_new_with_type() -> Result<()>21 fn func_new_with_type() -> Result<()> {
22     let mut config = Config::new();
23     config.enable_compiler(false);
24     config.concurrency_support(false);
25     let engine = Engine::new(&config)?;
26 
27     OomTest::new().test(|| {
28         let mut store = Store::try_new(&engine, ())?;
29         let ty = FuncType::try_new(&engine, [ValType::I32], [ValType::I32])?;
30         let _func = Func::try_new(&mut store, ty, |_caller, params, results| {
31             results[0] = params[0].clone();
32             Ok(())
33         })?;
34         Ok(())
35     })
36 }
37 
38 #[test]
func_call() -> Result<()>39 fn func_call() -> Result<()> {
40     let module_bytes = {
41         let mut config = Config::new();
42         config.concurrency_support(false);
43         let engine = Engine::new(&config)?;
44         Module::new(
45             &engine,
46             r#"(module (func (export "id") (param i32) (result i32) (local.get 0)))"#,
47         )?
48         .serialize()?
49     };
50     let mut config = Config::new();
51     config.enable_compiler(false);
52     config.concurrency_support(false);
53     let engine = Engine::new(&config)?;
54     let module = unsafe { Module::deserialize(&engine, &module_bytes)? };
55     let linker = Linker::<()>::new(&engine);
56     let instance_pre = linker.instantiate_pre(&module)?;
57 
58     OomTest::new().test(|| {
59         let mut store = Store::try_new(&engine, ())?;
60         let instance = instance_pre.instantiate(&mut store)?;
61         let id = instance.get_func(&mut store, "id").unwrap();
62         let mut results = [Val::I32(0)];
63         id.call(&mut store, &[Val::I32(42)], &mut results)?;
64         assert_eq!(results[0].unwrap_i32(), 42);
65         Ok(())
66     })
67 }
68 
69 #[tokio::test]
func_call_async() -> Result<()>70 async fn func_call_async() -> Result<()> {
71     let module_bytes = {
72         let mut config = Config::new();
73         config.concurrency_support(false);
74         let engine = Engine::new(&config)?;
75         Module::new(
76             &engine,
77             r#"(module (func (export "id") (param i32) (result i32) (local.get 0)))"#,
78         )?
79         .serialize()?
80     };
81     let mut config = Config::new();
82     config.enable_compiler(false);
83     config.concurrency_support(false);
84     let engine = Engine::new(&config)?;
85     let module = unsafe { Module::deserialize(&engine, &module_bytes)? };
86     let linker = Linker::<()>::new(&engine);
87     let instance_pre = linker.instantiate_pre(&module)?;
88 
89     OomTest::new()
90         .test_async(|| async {
91             let mut store = Store::try_new(&engine, ())?;
92             let instance = instance_pre.instantiate_async(&mut store).await?;
93             let id = instance.get_func(&mut store, "id").unwrap();
94             let mut results = [Val::I32(0)];
95             id.call_async(&mut store, &[Val::I32(42)], &mut results)
96                 .await?;
97             assert_eq!(results[0].unwrap_i32(), 42);
98             Ok(())
99         })
100         .await
101 }
102 
103 #[test]
func_typed() -> Result<()>104 fn func_typed() -> Result<()> {
105     let module_bytes = {
106         let mut config = Config::new();
107         config.concurrency_support(false);
108         let engine = Engine::new(&config)?;
109         Module::new(
110             &engine,
111             r#"(module (func (export "id") (param i32) (result i32) (local.get 0)))"#,
112         )?
113         .serialize()?
114     };
115     let mut config = Config::new();
116     config.enable_compiler(false);
117     config.concurrency_support(false);
118     let engine = Engine::new(&config)?;
119     let module = unsafe { Module::deserialize(&engine, &module_bytes)? };
120     let linker = Linker::<()>::new(&engine);
121     let instance_pre = linker.instantiate_pre(&module)?;
122 
123     OomTest::new().test(|| {
124         let mut store = Store::try_new(&engine, ())?;
125         let instance = instance_pre.instantiate(&mut store)?;
126         let id = instance.get_typed_func::<i32, i32>(&mut store, "id")?;
127         let result = id.call(&mut store, 42)?;
128         assert_eq!(result, 42);
129         Ok(())
130     })
131 }
132 
133 #[test]
func_ty() -> Result<()>134 fn func_ty() -> Result<()> {
135     let mut config = Config::new();
136     config.enable_compiler(false);
137     config.concurrency_support(false);
138     let engine = Engine::new(&config)?;
139 
140     OomTest::new().test(|| {
141         let mut store = Store::try_new(&engine, ())?;
142         let func = Func::try_wrap(&mut store, |x: i32| x * 2)?;
143         let ty = func.ty(&store);
144         assert_eq!(ty.params().len(), 1);
145         assert_eq!(ty.results().len(), 1);
146         Ok(())
147     })
148 }
149