rustdesk/libs/rust-sciter/tests/value.rs

#![allow(unused_variables)]

#[macro_use]
extern crate sciter;

use sciter::value::*;


#[test]
fn new_works() {
	let v = Value::new();
	assert!(v.is_undefined());
	assert!(!v.is_null());
}

#[test]
fn varray_works() {
  let val = varray![];
  assert!(val.is_array());
  assert_eq!(val.len(), 0);

  let val = varray![42];
  assert!(val.is_array());
  assert_eq!(val.len(), 1);

  let val = varray![1, 2.0, "three"];
  assert!(val.is_array());
  assert_eq!(val.len(), 3);
}

#[test]
fn vmap_works() {
  let map = vmap!{};
  assert!(map.is_map());
  assert_eq!(map.len(), 0);

  let map = vmap! {
    "one" => 1,
  };
  assert!(map.is_map());
  assert_eq!(map.len(), 1);

  let map = vmap! {
    "one" => 1,
    "two" => 2.0,
    "three" => "",
  };
  assert!(map.is_map());
  assert_eq!(map.len(), 3);
}

#[test]
fn null_works() {
 	let v = Value::null();
	assert!(!v.is_undefined());
	assert!(v.is_null());
}

#[test]
fn clear_works() {
	let mut v = Value::null();
	assert!(v.is_null());

	v.clear();
	assert!(!v.is_null());
	assert!(v.is_undefined());
}

#[test]
fn symbol_works() {
	let mut v = Value::symbol("hello");
	assert!(v.is_symbol());
	assert!(v.is_string());

	v.clear();
	assert!(v.is_undefined());
}

fn is_color_supported() -> bool {
	// e.g. `0x04000100`
	sciter::version_num() > 0x0400_0100
}

#[test]
fn color_works() {
	if !is_color_supported() { return; }

	// yellow R255, G255, B000
	// RGBA form in memory, ABGR in integer.
	let v = Value::color(0x0000_FFFF);
	assert!(v.is_color());
	assert_eq!(v.to_color(), Some(0x0000_FFFF));
}

#[test]
fn duration_works() {
	if !is_color_supported() { return; }

	let v = Value::duration(12.5);
	assert!(v.is_duration());
	assert_eq!(v.to_duration(), Some(12.5));
}

#[test]
fn angle_works() {
	if !is_color_supported() { return; }

	let v = Value::angle(1.0);
	assert!(v.is_angle());
	assert_eq!(v.to_angle(), Some(1.0));
}

#[test]
fn array_works() {
	let v = Value::array(0);
	assert!(v.is_array());
	assert!(v.is_empty());

	let v = Value::array(17);
	assert!(v.is_array());
	assert!(v.len() == 17);
}

#[test]
fn map_works() {
	let v = Value::map();
	assert!(v.is_map());
	assert!(v.is_empty());
}

#[test]
fn from_bool_works() {
	let v = Value::from(true);
	assert!(v.is_bool());
	let v = Value::from(false);
	assert!(v.is_bool());
}

#[test]
fn from_int_works() {
	let v = Value::from(1);
	assert!(v.is_int());
	assert!(!v.is_bool());

	Value::from(1 as i32);
	// Value::from(1 as u32);
}

#[test]
fn from_float_works() {
	let v = Value::from(1.0);
	assert!(v.is_float());
}


#[test]
fn from_str_works() {
	use std::str::FromStr;

	let v = Value::from("hello");
	assert!(v.is_string());

	let s = String::from("hello");
	let v = Value::from(s.as_str());

	let v = Value::from_str("hello");
	let v = Value::from_str(&s);
}

#[test]
fn from_int_seq_works() {
	let v: Value = [1,2,3].iter().cloned().collect();
	assert!(v.is_array());
	assert_eq!(v.len(), 3);
}

#[test]
fn from_str_seq_works() {
	// &str
	let v: Value = ["1","2","3"].iter().cloned().collect();
	assert!(v.is_array());
	assert_eq!(v.len(), 3);

	// String
	let v: Value = ["1","2","3"].iter().map(|x| x.to_string()).collect();
	assert!(v.is_array());
	assert_eq!(v.len(), 3);
	assert_eq!(v[2].as_string(), Some("3".to_string()));
}

#[test]
fn from_function_works() {
	// create from lambda
	let v = Value::from(|args: &[Value]| Value::from(args.len() as i32));
	assert!(v.is_native_function());

	let args = [Value::from(17), Value::from(42)];
	let r = v.call(None, &args, None);

	assert!(r.is_ok());
	assert_eq!(r.unwrap(), Value::from(args.len() as i32));

	// create from function
	fn inner_fn(args: &[Value]) -> Value {
		Value::array(args.len())
	}

	let v = Value::from(inner_fn);
	assert!(v.is_native_function());
}

#[test]
fn from_result_works() {
	// create Err variant
	let result: Result<i32, String> = Err("unknown error".to_string());
	let v = Value::from(result);
	assert_eq!(v.as_string().unwrap(), "unknown error");

	// create Ok variant
	let result: Result<i32, String> = Ok(100);
	let v = Value::from(result);
	assert_eq!(v.to_int().unwrap(), 100);
}

#[test]
fn parse_works() {
	let items = ["", "null", "1", "\"2\"", "2.0", "true", "[3, 4]", r##"{"5": 5, "6": 6, seven: "seven"}"##];
	for item in &items {
		let r = Value::parse(item);
		if let Err(num) = r {
			panic!("parse({}) failed on character {} of {}", item, num, item.len());
		}
	}

	let v :Value = "4".parse().unwrap();
	assert_eq!(v.to_int(), Some(4));

	let v = "true".parse::<Value>().unwrap();
	assert_eq!(v.to_bool(), Some(true));
}

#[test]	// crashes with 1.7.0 i686-pc-windows-msvc
#[should_panic(expected="failed on character")]
fn parse_fail_works() {
	let item = "{item: "; // invalid json
	let r = Value::parse(item);
	if let Err(num) = r {
		panic!("parse({}) failed on character {} of {}", item, num, item.len());
	}
}

#[test]
fn pack_args_works() {
	let args = pack_args!();
	assert_eq!(args.len(), 0);

	let args = pack_args!(777);
	assert_eq!(args.len(), 1);

	let args = pack_args!(1,2,3);
	assert_eq!(args.len(), 3);

	let args = pack_args!(1, "2", 3.0);
	assert_eq!(args.len(), 3);

	let args = pack_args!(1,2,3);
	let unpacked = unsafe { Value::unpack_from(args.as_ptr(), args.len() as u32) };
	assert_eq!(unpacked.len(), 3);
	assert_eq!(unpacked[0], Value::from(1));
}

#[test]
fn make_args_works() {
	let args = make_args!();
	assert_eq!(args.len(), 0);

	let args = make_args!(777);
	assert_eq!(args.len(), 1);

	let args = make_args!(1,2,3);
	assert_eq!(args.len(), 3);

	let args = make_args!(1, "2", 3.0);
	assert_eq!(args.len(), 3);
}

#[test]
fn append_works() {
	let mut v = Value::new();
	v.push(Value::from(1));
	v.push(Value::from("2"));
	v.push(Value::from(3.0));
	v.push(Value::from(false));

	assert!(v.is_array());
	assert_eq!(v.len(), 4);
}

#[test]
fn to_works() {
	// Value has some implicit conversions:
	// bool or int -> int
	// int or float or length -> float
	// function or string -> string

	let vint = Value::from(1);
	assert!(vint.is_int());
	assert!(vint.to_int().is_some());
	assert!(vint.to_float().is_some());
	assert_eq!(vint.to_int().unwrap(), 1);

	let vbool = Value::from(false);
	assert!(vbool.is_bool());
	assert!(!vbool.is_int());
	assert!(vbool.to_bool().is_some());
	assert!(vbool.to_int().is_some());
	assert_eq!(vbool.to_bool().unwrap(), false);

	assert_eq!(Value::from(4.2).to_float().unwrap(), 4.2);

	assert_eq!(Value::from("4.2").as_string().unwrap(), "4.2");
}

#[test]
fn into_works() {

	let v = Value::from(1);
	assert!(v.is_int());

	let v: Value = Value::from(1);
	assert!(v.is_int());

	let v: Value = 1.into();
	assert!(v.is_int());

	let mut v = Value::new();
	v.push(false);
	v.push(1);
	v.push(3.0);
	v.push("2");
	assert!(v.is_array());
	assert_eq!(v.len(), 4);

	assert_eq!(Value::from(1).into_string(), "1");
	assert_eq!(Value::from("hello").into_string(), r#""hello""#);
}

#[test]
fn bytes_work() {
	let b = [1,2,3];
	let v = Value::from(&b[..]);
	assert!(v.is_bytes());
	assert_eq!(v.as_bytes().expect("must be bytes"), [1,2,3]);
}

#[test]
fn index_works() {
	let mut v = Value::new();
	v.push(Value::from(1));
	v.push(Value::from(2));
	v.push(Value::from(3));

	println!("v {:?}", v);

	assert_eq!(v.len(), 3);
	assert_eq!(v[0], 1.into());

	v.set(1, 17);
	assert_eq!(v[1], 17.into());

	let mut v: Value = r##"{"5": 5, "6": 6, seven: "seven"}"##.parse().unwrap();
	let key = Value::from("seven");
	v.set_item(key.clone(), Value::from(7.0));
	println!("map {:?}", v);
	assert_eq!(v.get_item(key), Value::from(7.0));

	assert_eq!(v.key_at(0), Value::from("5"));
	assert_eq!(v.key_at(2), Value::symbol("seven"));
	assert_eq!(v.get_item(v.key_at(1)), Value::from(6));

	// simple syntax:
	let mut v = Value::map();
	v.set_item("seven", 7);
	v.set_item("ten", 10);
	v.set_item("six", 6);
	assert_eq!(v["seven"], 7.into());
}

#[test]
fn display_works() {
	println!("\nvalue strings: new {}, null {}, bool {}, int {}, float {}, symbol {}, str {}",
		Value::new(), Value::null(), Value::from(true), Value::from(123), Value::from(4.2),
		Value::symbol("symbol"), Value::from("hello"));

	// assert!(false);
}

#[test]
fn debug_works() {
	println!("\nvalue strings: {:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}",
		Value::new(), Value::null(), Value::from(true), Value::from(123), Value::from(4.2),
		Value::symbol("symbol"), Value::from("hello"));

	// assert!(false);
}

#[test]
fn thread_works() {
	let mut v = Value::map();
	let tid = std::thread::spawn(move || {
		v.set_item("seven", 7);
		assert_eq!(v.len(), 1);
	});
	tid.join().unwrap();
}

#[test]
fn iterators_work() {
	let v: Value = [1,2,3].iter().cloned().collect();

	// `&v` == `v.into_iter()`
	for a in &v {
		assert!(a.is_int());
	}

	for a in v.into_iter() {
		assert!(a.is_int());
	}
}

#[test]
fn back_iter() {
	let v: Value = [1,2,3].iter().cloned().collect();

	let mut iter = v.into_iter();
	assert_eq!(Some(1.into()), iter.next());
	assert_eq!(Some(3.into()), iter.next_back());
	assert_eq!(Some(2.into()), iter.next_back());
	assert_eq!(None, iter.next_back());
	assert_eq!(None, iter.next());

	assert_eq!(v.into_iter().rev().map(|a| a.to_int().unwrap()).sum::<i32>(), 1 + 2 + 3);
}

#[test]
fn keys_work() {
	let v = Value::parse("five: 5, seven: 7").unwrap();
	for k in v.keys() {
		assert!(k.is_string());
	}
}

#[test]
fn values_work() {
	let v = Value::parse("five: 5, seven: 7").unwrap();
	for a in v.values() {
		assert!(a.is_int());
	}
}

#[test]
fn items_work() {
	let v = Value::parse("five: 5, seven: 7").unwrap();
	for (k,a) in v.items() {
		assert!(k.is_string());
		assert!(a.is_int());
	}
}