move rust-sciter in

libs/rust-sciter/tests/graphics.rs

@@ -0,0 +1,195 @@
+// Note: there is an issue in Sciter that you can't just call its functions out of nowhere,
+// you are supposed to have a main thread.
+// Since Rust always spawns a thread per test (it does not matter, to spawn 1 or more threads),
+// so we have a problem here.
+// If I could create a dedicated "main" thread per test module, that would be fine.
+
+#![allow(unused_variables)]
+
+extern crate sciter;
+
+use sciter::graphics::*;
+
+const OK: Result<()> = Ok(());
+
+macro_rules! assert_ok {
+  ($left:expr, $right:expr) => {
+    assert_eq!($left, $right.map(|_| ()));
+  };
+}
+
+fn get() -> Image {
+  Image::create((100, 100), true).expect("Can't create a `100x100` image")
+}
+
+#[test]
+#[ignore]
+fn image_new() {
+  let ok = Image::create((100, 100), false);
+  assert_ok!(OK, ok);
+
+  let ok = Image::create((100, 100), true);
+  assert_ok!(OK, ok);
+}
+
+#[test]
+#[ignore]
+fn image_dimensions() {
+  let size = get().dimensions().unwrap();
+  assert_eq!((100, 100), size);
+}
+
+#[test]
+#[ignore]
+fn image_save() {
+  let ok = get().save(SaveImageEncoding::Raw);
+  assert!(ok.is_ok());
+  assert_eq!(ok.unwrap().len(), 100 * 100 * 4);
+
+  fn verify(image: &Image, format: SaveImageEncoding) -> Result<()> {
+    image.save(format).map(|_| ())
+  }
+
+  let image = get();
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Png));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Jpeg(10)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Jpeg(100)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(0)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(10)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(100)));
+}
+
+#[test]
+#[ignore]
+fn image_load() {
+  fn verify(image: &Image, format: SaveImageEncoding) -> Result<()> {
+    let ok = image.save(format).and_then(|saved| Image::load(&saved));
+    ok.map(|_| ())
+  }
+
+  let image = get();
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Png));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Jpeg(10)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Jpeg(100)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(0)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(10)));
+  assert_ok!(OK, verify(&image, SaveImageEncoding::Webp(100)));
+
+  let r = image.save(SaveImageEncoding::Raw).and_then(|saved| {
+    let size = image.dimensions().unwrap();
+    Image::with_data(size, true, &saved)
+  });
+  assert_ok!(OK, r);
+}
+
+#[test]
+#[ignore]
+#[cfg_attr(rustfmt, rustfmt_skip)]
+fn load_formats() {
+	// The following images were taken from https://github.com/mathiasbynens/small.
+
+	fn verify(data: &[u8]) -> Result<()> {
+		Image::load(data).map(|_| ())
+	}
+
+	let bmp = [
+	  0x42,0x4d,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  	0x1a,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x01,0x00,
+  	0x01,0x00,0x01,0x00,0x18,0x00,0x00,0x00,0xff,0x00
+	];
+
+	let gif = [
+	  0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,
+	  0x80,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0x21,
+	  0xf9,0x04,0x01,0x00,0x00,0x00,0x00,0x2c,0x00,0x00,
+	  0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x01,0x44,
+	  0x00,0x3b
+	];
+
+	let ico = [
+	  0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x00,0x00,
+	  0x01,0x00,0x18,0x00,0x30,0x00,0x00,0x00,0x16,0x00,
+	  0x00,0x00,0x28,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+	  0x02,0x00,0x00,0x00,0x01,0x00,0x18,0x00,0x00,0x00,
+	  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	  0x00,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0x00,0x00
+	];
+
+	let jpeg = [ // a 121-byte one from d75477e
+	  0xff,0xd8,0xff,0xdb,0x00,0x43,0x00,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+	  0x01,0xff,0xc2,0x00,0x0b,0x08,0x00,0x01,0x00,0x01,
+	  0x01,0x01,0x11,0x00,0xff,0xc4,0x00,0x14,0x00,0x01,
+	  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xff,0xda,
+	  0x00,0x08,0x01,0x01,0x00,0x00,0x00,0x01,0x3f,0xff,
+	  0xd9
+	];
+
+	let png = [
+	  0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,
+	  0x00,0x0d,0x49,0x48,0x44,0x52,0x00,0x00,0x00,0x01,
+	  0x00,0x00,0x00,0x01,0x08,0x06,0x00,0x00,0x00,0x1f,
+	  0x15,0xc4,0x89,0x00,0x00,0x00,0x0a,0x49,0x44,0x41,
+	  0x54,0x78,0x9c,0x63,0x00,0x01,0x00,0x00,0x05,0x00,
+	  0x01,0x0d,0x0a,0x2d,0xb4,0x00,0x00,0x00,0x00,0x49,
+	  0x45,0x4e,0x44,0xae,0x42,0x60,0x82
+	];
+
+	let webp = [
+	  0x52,0x49,0x46,0x46,0x12,0x00,0x00,0x00,0x57,0x45,
+	  0x42,0x50,0x56,0x50,0x38,0x4c,0x06,0x00,0x00,0x00,
+	  0x2f,0x41,0x6c,0x6f,0x00,0x6b
+	];
+
+  println!();
+  println!("verify(&bmp): {}", verify(&bmp).is_ok());
+  println!("verify(&gif): {}", verify(&gif).is_ok());
+  println!("verify(&ico): {}", verify(&ico).is_ok());
+  println!("verify(&jpeg) {}", verify(&jpeg).is_ok());
+  println!("verify(&png): {}", verify(&png).is_ok());
+  println!("verify(&webp) {}", verify(&webp).is_ok());
+
+  #[cfg(windows)]
+  assert_ok!(OK, verify(&bmp));
+  assert_ok!(OK, verify(&gif));
+  #[cfg(windows)]
+  assert_ok!(OK, verify(&ico));
+  assert_ok!(OK, verify(&jpeg));
+  assert_ok!(OK, verify(&png));
+  assert_ok!(OK, verify(&webp));
+}
+
+#[test]
+#[ignore]
+fn image_clear() {
+  assert_eq!(OK, get().clear());
+  assert_eq!(OK, get().clear_with(rgb(255, 255, 255)));
+}
+
+#[test]
+#[ignore]
+fn make_color() {
+  // ABGR
+  assert_eq!(0xFF000000, rgb(0, 0, 0));
+  assert_eq!(0x00000000, rgba((0, 0, 0), 0));
+
+  assert_eq!(0xFF112233, rgb(0x33, 0x22, 0x11));
+}
+
+#[test]
+#[ignore]
+fn paint() {
+  let mut image = Image::create((100, 100), false).unwrap();
+  let ok = image.paint(|gfx, size| {
+    gfx.rectangle((5.0, 5.0), (size.0 - 5.0, size.1 - 5.0))?;
+    Ok(())
+  });
+  assert_ok!(OK, ok);
+}

libs/rust-sciter/tests/value.rs

@@ -0,0 +1,468 @@
+#![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());
+	}
+}