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

   1 //! Tests that some of our more obscure intrinsics work properly.
   2
   3 use std::convert::TryFrom;
   4 use std::fmt::Debug;
   5
   6 use js_sys::{Object, RangeError, Reflect};
   7 use wasm_bindgen::{JsCast, JsValue};
   8 use wasm_bindgen_test::wasm_bindgen_test;
   9
  10 // Shorter `JsValue::from(i32)`.
  11 fn int(x: i32) -> JsValue {
  12     JsValue::from(x)
  13 }
  14
  15 #[wasm_bindgen_test]
  16 fn bitwise() {
  17     assert_eq!(int(0b1110) & int(0b0111), 0b0110);
  18     assert_eq!(int(0b1000) | int(0b0010), 0b1010);
  19     assert_eq!(int(0b1110) ^ int(0b0100), 0b1010);
  20     assert_eq!(int(0x00ffffff).bit_not(), 0xff000000u32 as i32);
  21
  22     assert_eq!(int(0b0001) << int(2), 0b0100);
  23     assert_eq!(int(0b1000) >> int(2), 0b0010);
  24     assert_eq!(int(-0b1000) >> int(2), -0b0010);
  25     // Note that bit-wise, this is the same as the above `-0b1000`.
  26     assert_eq!(
  27         JsValue::from(0xfffffff8u32).unsigned_shr(&int(2)),
  28         0x3ffffffe
  29     );
  30 }
  31
  32 #[wasm_bindgen_test]
  33 fn arithmetic() {
  34     assert_eq!(-int(12), -12);
  35     assert_eq!(int(1) + int(2), 3);
  36     assert_eq!(int(1) - int(2), -1);
  37     assert_eq!(int(10) / int(5), 2);
  38     assert_eq!(int(42).checked_div(&int(6)), 7);
  39     // Note that this doesn't throw for regular numbers, since they just give
  40     // `NaN` for invalid results.
  41     assert!(JsValue::bigint_from_str("0")
  42         .checked_div(&JsValue::bigint_from_str("0"))
  43         .dyn_into::<RangeError>()
  44         .is_ok());
  45     assert_eq!(int(12) * int(34), 408);
  46     assert_eq!(int(17) % int(10), 7);
  47     assert_eq!(int(2).pow(&int(8)), 256)
  48 }
  49
  50 #[wasm_bindgen_test]
  51 fn cmp() {
  52     assert!(int(2).lt(&int(3)));
  53     assert!(!int(2).lt(&int(2)));
  54
  55     assert!(int(2).le(&int(3)));
  56     assert!(int(2).le(&int(2)));
  57
  58     assert!(int(3).ge(&int(2)));
  59     assert!(int(3).ge(&int(3)));
  60
  61     assert!(int(3).gt(&int(2)));
  62     assert!(!int(3).gt(&int(3)));
  63
  64     assert!(int(2) == int(2));
  65     assert!(int(2) != int(3));
  66
  67     assert!(int(2) != JsValue::from_str("2"));
  68     assert!(int(2).loose_eq(&JsValue::from_str("2")));
  69 }
  70
  71 #[wasm_bindgen_test]
  72 fn types() {
  73     assert!(
  74         Reflect::get(&js_sys::global(), &JsValue::from_str("Number"))
  75             .unwrap()
  76             .is_function()
  77     );
  78     assert!(JsValue::UNDEFINED.is_undefined());
  79     assert!(JsValue::NULL.is_null());
  80     assert!(Object::new().is_object());
  81     assert!(JsValue::symbol(None).is_symbol());
  82     assert!(JsValue::from_str("hi").is_string());
  83     assert!(JsValue::bigint_from_str("5").is_bigint());
  84     assert_eq!(int(5).js_typeof(), "number");
  85     assert_eq!(JsValue::bigint_from_str("5").js_typeof(), "bigint");
  86     assert_eq!(JsValue::NULL.js_typeof(), "object");
  87 }
  88
  89 #[wasm_bindgen_test]
  90 fn misc() {
  91     assert!(JsValue::from_str("Number").js_in(&js_sys::global()));
  92     assert!(!JsValue::from_str("frob").js_in(&js_sys::global()));
  93
  94     assert_eq!(int(5).unchecked_into_f64(), 5.0);
  95     assert_eq!(JsValue::from_str("5").unchecked_into_f64(), 5.0);
  96
  97     assert_eq!(f64::try_from(int(5)), Ok(5.0));
  98     assert_eq!(f64::try_from(JsValue::from_str("5")), Ok(5.0));
  99     assert!(f64::try_from(JsValue::from_str("hi")).unwrap().is_nan());
 100     assert!(f64::try_from(JsValue::symbol(None)).is_err());
 101 }
 102
 103 fn debug(x: impl Debug) -> String {
 104     format!("{x:?}")
 105 }
 106
 107 #[wasm_bindgen_test]
 108 fn debug_string() {
 109     assert_eq!(debug(int(5)), "JsValue(5)");
 110     assert_eq!(debug(JsValue::TRUE), "JsValue(true)");
 111     assert_eq!(debug(JsValue::symbol(None)), "JsValue(Symbol)");
 112     assert_eq!(debug(JsValue::from_str("hi")), "JsValue(\"hi\")");
 113 }