vendor/wasm-bindgen/tests/wasm/simple.rs

   1 use wasm_bindgen::prelude::*;
   2 use wasm_bindgen::{intern, unintern, JsCast};
   3 use wasm_bindgen_test::*;
   4
   5 #[wasm_bindgen(module = "tests/wasm/simple.js")]
   6 extern "C" {
   7     fn test_add();
   8     fn test_string_arguments();
   9     fn test_return_a_string();
  10     fn test_wrong_types();
  11     fn test_other_exports_still_available();
  12     fn test_jsvalue_typeof();
  13
  14     fn optional_str_none(a: Option<&str>);
  15     fn optional_str_some(a: Option<&str>);
  16     fn optional_slice_none(a: Option<&[u8]>);
  17     fn optional_slice_some(a: Option<&[u8]>);
  18     fn optional_string_none(a: Option<String>);
  19     fn optional_string_some(a: Option<String>);
  20     fn optional_string_some_empty(a: Option<String>);
  21     fn return_string_none() -> Option<String>;
  22     fn return_string_some() -> Option<String>;
  23     fn test_rust_optional();
  24     #[wasm_bindgen(js_name = import_export_same_name)]
  25     fn js_import_export_same_name();
  26
  27     #[wasm_bindgen(js_name = RenamedInRust)]
  28     type Renamed;
  29     fn new_renamed() -> Renamed;
  30
  31     fn test_string_roundtrip();
  32 }
  33
  34 #[wasm_bindgen_test]
  35 fn add() {
  36     test_add();
  37 }
  38
  39 #[wasm_bindgen]
  40 pub fn simple_add(a: u32, b: u32) -> u32 {
  41     a + b
  42 }
  43
  44 #[wasm_bindgen]
  45 pub fn simple_add3(a: u32) -> u32 {
  46     a + 3
  47 }
  48
  49 #[wasm_bindgen]
  50 pub fn simple_get2(_b: bool) -> u32 {
  51     2
  52 }
  53
  54 #[wasm_bindgen]
  55 pub fn simple_return_and_take_bool(a: bool, b: bool) -> bool {
  56     a && b
  57 }
  58
  59 #[wasm_bindgen]
  60 pub fn simple_raw_pointers_work(a: *mut u32, b: *const u8) -> *const u32 {
  61     unsafe {
  62         (*a) = (*b) as u32;
  63         return a;
  64     }
  65 }
  66
  67 #[wasm_bindgen_test]
  68 fn string_arguments() {
  69     test_string_arguments();
  70 }
  71
  72 #[wasm_bindgen]
  73 pub fn simple_assert_foo_and_bar(a: &str, b: &str) {
  74     assert_eq!(a, "foo2");
  75     assert_eq!(b, "bar");
  76 }
  77
  78 #[wasm_bindgen]
  79 pub fn simple_assert_foo(a: &str) {
  80     assert_eq!(a, "foo");
  81 }
  82
  83 #[wasm_bindgen_test]
  84 fn return_a_string() {
  85     test_return_a_string();
  86 }
  87
  88 #[wasm_bindgen]
  89 pub fn simple_clone(a: &str) -> String {
  90     a.to_string()
  91 }
  92
  93 #[wasm_bindgen]
  94 pub fn simple_concat(a: &str, b: &str, c: i8) -> String {
  95     format!("{} {} {}", a, b, c)
  96 }
  97
  98 #[wasm_bindgen_test]
  99 fn wrong_types() {
 100     test_wrong_types();
 101 }
 102
 103 #[wasm_bindgen]
 104 pub fn simple_int(_a: u32) {}
 105
 106 #[wasm_bindgen]
 107 pub fn simple_str(_a: &str) {}
 108
 109 #[wasm_bindgen_test]
 110 fn other_exports() {
 111     test_other_exports_still_available();
 112 }
 113
 114 #[no_mangle]
 115 pub extern "C" fn foo(_a: u32) {}
 116
 117 #[wasm_bindgen_test]
 118 fn jsvalue_typeof() {
 119     test_jsvalue_typeof();
 120 }
 121
 122 #[wasm_bindgen]
 123 pub fn is_object(val: &JsValue) -> bool {
 124     val.is_object()
 125 }
 126
 127 #[wasm_bindgen]
 128 pub fn is_function(val: &JsValue) -> bool {
 129     val.is_function()
 130 }
 131
 132 #[wasm_bindgen]
 133 pub fn is_string(val: &JsValue) -> bool {
 134     val.is_string()
 135 }
 136
 137 #[wasm_bindgen]
 138 extern "C" {
 139     #[derive(Clone)]
 140     type Array;
 141     #[wasm_bindgen(constructor)]
 142     fn new() -> Array;
 143     #[wasm_bindgen(method, catch)]
 144     fn standardized_method_this_js_runtime_doesnt_implement_yet(
 145         this: &Array,
 146     ) -> Result<(), JsValue>;
 147 }
 148
 149 #[wasm_bindgen_test]
 150 fn binding_to_unimplemented_apis_doesnt_break_everything() {
 151     let array = Array::new();
 152     let res = array.standardized_method_this_js_runtime_doesnt_implement_yet();
 153     assert!(res.is_err());
 154 }
 155
 156 #[wasm_bindgen_test]
 157 fn optional_slices() {
 158     optional_str_none(None);
 159     optional_str_some(Some("x"));
 160     optional_str_some(Some(intern("x")));
 161     unintern("x");
 162     optional_str_some(Some("x"));
 163     optional_slice_none(None);
 164     optional_slice_some(Some(&[1, 2, 3]));
 165     optional_string_none(None);
 166     optional_string_some_empty(Some(String::new()));
 167     optional_string_some(Some("abcd".to_string()));
 168
 169     assert_eq!(return_string_none(), None);
 170     assert_eq!(return_string_some(), Some("foo".to_string()));
 171     test_rust_optional();
 172 }
 173
 174 #[wasm_bindgen]
 175 pub fn take_optional_str_none(x: Option<String>) {
 176     assert!(x.is_none())
 177 }
 178 #[wasm_bindgen]
 179 pub fn take_optional_str_some(x: Option<String>) {
 180     assert_eq!(x, Some(String::from("hello")));
 181 }
 182
 183 #[wasm_bindgen]
 184 pub fn return_optional_str_none() -> Option<String> {
 185     None
 186 }
 187
 188 #[wasm_bindgen]
 189 pub fn return_optional_str_some() -> Option<String> {
 190     Some("world".to_string())
 191 }
 192
 193 #[wasm_bindgen_test]
 194 fn renaming_imports_and_instanceof() {
 195     let null = JsValue::NULL;
 196     assert!(!null.is_instance_of::<Renamed>());
 197
 198     let arr: JsValue = Array::new().into();
 199     assert!(!arr.is_instance_of::<Renamed>());
 200
 201     let renamed: JsValue = new_renamed().into();
 202     assert!(renamed.is_instance_of::<Renamed>());
 203 }
 204
 205 #[wasm_bindgen]
 206 pub fn import_export_same_name() {
 207     js_import_export_same_name();
 208 }
 209
 210 #[wasm_bindgen_test]
 211 fn string_roundtrip() {
 212     test_string_roundtrip();
 213 }
 214
 215 #[wasm_bindgen]
 216 pub fn do_string_roundtrip(s: String) -> String {
 217     s
 218 }
 219
 220 #[wasm_bindgen_test]
 221 fn externref_heap_live_count() {
 222     let x = wasm_bindgen::externref_heap_live_count();
 223     let y = JsValue::null().clone();
 224     assert!(wasm_bindgen::externref_heap_live_count() > x);
 225     drop(y);
 226     assert_eq!(x, wasm_bindgen::externref_heap_live_count());
 227 }