value serialization/deserialization tests

Cargo.lock

@@ -238,6 +238,7 @@ name = "air-interpreter-value"
 version = "0.1.0"
 dependencies = [
  "indexmap 2.1.0",
+ "maplit",
  "serde",
  "serde_json",
 ]

crates/air-lib/interpreter-value/Cargo.toml

@@ -15,4 +15,7 @@ indexmap = "2.1.0"
 serde = { version = "1.0.195", features = ["rc"] }
 serde_json = "1.0.108"
 
+[dev-dependencies]
+maplit = "1.0.2"
+
 [features]

crates/air-lib/interpreter-value/src/value/mod.rs

@@ -790,34 +790,6 @@ impl JValue {
 }
 
 /// The default value is `Value::Null`.
-///
-/// This is useful for handling omitted `Value` fields when deserializing.
-///
-/// # Examples
-///
-/// ```
-/// # use serde::Deserialize;
-/// use serde_json::Value;
-///
-/// #[derive(Deserialize)]
-/// struct Settings {
-///     level: i32,
-///     #[serde(default)]
-///     extras: Value,
-/// }
-///
-/// # fn try_main() -> Result<(), serde_json::Error> {
-/// let data = r#" { "level": 42 } "#;
-/// let s: Settings = serde_json::from_str(data)?;
-///
-/// assert_eq!(s.level, 42);
-/// assert_eq!(s.extras, Value::Null);
-/// #
-/// #     Ok(())
-/// # }
-/// #
-/// # try_main().unwrap()
-/// ```
 impl Default for JValue {
     #[inline]
     fn default() -> JValue {

crates/air-lib/interpreter-value/tests/value/de.rs

@@ -0,0 +1,83 @@
+use air_interpreter_value::JValue;
+use serde_json::Number;
+
+#[test]
+fn test_deserialize_null() {
+    let inp = "null";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Null);
+}
+
+#[test]
+fn test_deserialize_bool_false() {
+    let inp = "false";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Bool(false));
+}
+
+#[test]
+fn test_deserialize_bool() {
+    let inp = "true";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Bool(true));
+}
+
+#[test]
+fn test_deserialize_i64() {
+    let inp = "42";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Number(42.into()));
+}
+
+#[test]
+fn test_deserialize_i64_2() {
+    let inp = "-42";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Number((-42).into()));
+}
+
+#[test]
+fn test_deserialize_f64() {
+    let inp = "-3140000000000000.0";
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::Number(Number::from_f64(-3.14e15).unwrap()));
+}
+
+#[test]
+fn test_deserialize_string_simple() {
+    let inp = r#""simple string""#;
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::string("simple string"));
+}
+
+#[test]
+fn test_deserialize_string_escaping() {
+    let inp = r#""simple\" string""#;
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::string("simple\" string"));
+}
+
+#[test]
+fn test_deserialize_array() {
+    let inp = r#"[42,8,12]"#;
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::array_from_iter(vec![42, 8, 12].into_iter()));
+}
+
+#[test]
+fn test_deserialize_object() {
+    let inp = r#"{"a":18,"b":42}"#;
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    let expected = JValue::object(maplit::btreemap! {
+        "b".into() => 42.into(),
+        "a".into() => 18.into(),
+    });
+    assert_eq!(val, expected);
+}
+
+#[test]
+fn test_deserialize_object_ordered() {
+    let inp = r#"{"a":18,"b":42}"#;
+    let val: JValue = serde_json::from_str(inp).unwrap();
+    assert_eq!(val, JValue::object_from_pairs(vec![("b", 42), ("a", 18)]));
+}

crates/air-lib/interpreter-value/tests/value/main.rs

@@ -0,0 +1,2 @@
+mod de;
+mod ser;

crates/air-lib/interpreter-value/tests/value/ser.rs

@@ -0,0 +1,82 @@
+use air_interpreter_value::JValue;
+use serde_json::Number;
+
+#[test]
+fn test_serialize_null() {
+    let val = JValue::Null;
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "null");
+}
+
+#[test]
+fn test_serialize_bool_false() {
+    let val = JValue::Bool(false);
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "false");
+}
+
+#[test]
+fn test_serialize_bool() {
+    let val = JValue::Bool(true);
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "true");
+}
+
+#[test]
+fn test_serialize_i64() {
+    let val = JValue::Number(42.into());
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "42");
+}
+
+#[test]
+fn test_serialize_i64_2() {
+    let val = JValue::Number((-42).into());
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "-42");
+}
+
+#[test]
+fn test_serialize_f64() {
+    let val = JValue::Number(Number::from_f64(-3.14e15).unwrap());
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, "-3140000000000000.0");
+}
+
+#[test]
+fn test_serialize_string_simple() {
+    let val = JValue::string("simple string");
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, r#""simple string""#);
+}
+
+#[test]
+fn test_serialize_string_escaping() {
+    let val = JValue::string("simple\" string");
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, r#""simple\" string""#);
+}
+
+#[test]
+fn test_serialize_array() {
+    let val = JValue::array_from_iter(vec![42, 8, 12].into_iter());
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, r#"[42,8,12]"#);
+}
+
+#[test]
+fn test_serialize_object() {
+    let val = JValue::object(maplit::btreemap! {
+        "b".into() => 42.into(),
+        "a".into() => 18.into(),
+    });
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, r#"{"a":18,"b":42}"#);
+}
+
+#[test]
+fn test_serialize_object_ordered() {
+    let val = JValue::object_from_pairs(vec![("b", 42), ("a", 18)]);
+    let res = serde_json::to_string(&val).unwrap();
+    assert_eq!(res, r#"{"a":18,"b":42}"#);
+}