uptown_funk 0.1.3

Define host functions compatible with Wasmer and Wasmtime
Documentation 
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

use uptown_funk::{host_functions, memory::Memory, HostFunctions};
#[cfg(feature = "vm-wasmer")]
use wasmer::{self, Exportable};
#[cfg(feature = "vm-wasmtime")]
use wasmtime;

use std::fs::read;

mod common;
use common::*;

#[host_functions(namespace = "env")]
impl Empty {
    fn count_a(&self, words: &str) -> i32 {
        words.matches("a").count() as i32
    }

    fn add(&self, a: &str, b: &str, c: &mut [u8]) {
        c[..a.len()].copy_from_slice(a.as_bytes());
        c[a.len()..].copy_from_slice(b.as_bytes());
    }
}

#[cfg(feature = "vm-wasmtime")]
#[test]
fn wasmtime_ref_str_test() {
    let store = wasmtime::Store::default();
    let wasm = read("tests/wasm/ref_str.wasm")
        .expect("Wasm file not found. Did you run ./build.sh inside the tests/wasm/ folder?");
    let module = wasmtime::Module::new(store.engine(), wasm).unwrap();
    let mut linker = wasmtime::Linker::new(&store);

    let memory_ty = wasmtime::MemoryType::new(wasmtime::Limits::new(32, None));
    let memory = wasmtime::Memory::new(&store, memory_ty);
    linker.define("env", "memory", memory.clone()).unwrap();

    let empty = Empty {};
    let instance_state = SimpleExcutor {
        memory: Memory::from(memory),
    };
    empty.add_to_linker(instance_state, &mut linker);

    let instance = linker.instantiate(&module).unwrap();
    let test_count = instance
        .get_func("test_count")
        .unwrap()
        .get0::<()>()
        .unwrap();
    assert_eq!(test_count().is_ok(), true);

    let test_add = instance.get_func("test_add").unwrap().get0::<()>().unwrap();
    assert_eq!(test_add().is_ok(), true);
}

#[cfg(feature = "vm-wasmer")]
#[test]
fn wasmer_ref_str_test() {
    let store = wasmer::Store::default();
    let wasm = read("tests/wasm/ref_str.wasm")
        .expect("Wasm file not found. Did you run ./build.sh inside the tests/wasm/ folder?");
    let module = wasmer::Module::new(&store, wasm).unwrap();
    let mut wasmer_linker = uptown_funk::wasmer::WasmerLinker::new();

    let memory_ty = wasmer::MemoryType::new(32, None, false);
    let memory = wasmer::Memory::new(&store, memory_ty).unwrap();
    wasmer_linker.add("env", "memory", memory.to_export());

    let empty = Empty {};
    let instance_state = SimpleExcutor {
        memory: Memory::Wasmer(memory),
    };
    empty.add_to_wasmer_linker(instance_state, &mut wasmer_linker, &store);

    let instance = wasmer::Instance::new(&module, &wasmer_linker).unwrap();
    let test_count = instance
        .exports
        .get_function("test_count")
        .unwrap()
        .native::<(), ()>()
        .unwrap();

    assert_eq!(test_count.call().is_ok(), true);

    let test_add = instance
        .exports
        .get_function("test_add")
        .unwrap()
        .native::<(), ()>()
        .unwrap();

    assert_eq!(test_add.call().is_ok(), true);
}