#![doc(
html_logo_url = "https://storage.googleapis.com/fdo-gitlab-uploads/project/avatar/3213/zbus-logomark.png"
)]
#[macro_use]
mod utils;
pub use utils::*;
mod array;
pub use array::*;
mod basic;
pub use basic::*;
mod dict;
pub use dict::*;
mod encoding_context;
pub use encoding_context::*;
mod fd;
pub use fd::*;
mod object_path;
pub use crate::object_path::*;
mod ser;
pub use ser::*;
mod de;
pub use de::*;
mod signature;
pub use crate::signature::*;
mod str;
pub use crate::str::*;
mod structure;
pub use crate::structure::*;
mod maybe;
pub use crate::maybe::*;
mod value;
pub use value::*;
mod error;
pub use error::*;
#[macro_use]
mod r#type;
pub use r#type::*;
mod from_value;
pub use from_value::*;
mod into_value;
pub use into_value::*;
mod owned_value;
pub use owned_value::*;
mod framing_offset_size;
mod framing_offsets;
mod signature_parser;
pub mod derive {
pub use zvariant_derive::{DeserializeDict, SerializeDict, Type, TypeDict};
}
extern crate self as zvariant;
#[doc(hidden)]
pub mod export {
pub use serde;
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use std::convert::{TryFrom, TryInto};
#[cfg(feature = "arrayvec")]
use arrayvec::{ArrayString, ArrayVec};
use byteorder::{self, ByteOrder, BE, LE};
#[cfg(feature = "arrayvec")]
use std::str::FromStr;
use glib::{Bytes, FromVariant, Variant};
use serde::{Deserialize, Serialize};
use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use zvariant_derive::{DeserializeDict, SerializeDict, Type, TypeDict};
use crate::{from_slice, from_slice_fds, from_slice_for_signature};
use crate::{to_bytes, to_bytes_fds, to_bytes_for_signature};
use crate::{Array, Dict, EncodingContext as Context, EncodingFormat};
use crate::{Basic, DeserializeValue, Error, Result, SerializeValue, Type, Value};
use crate::{Fd, ObjectPath, Signature, Str, Structure};
macro_rules! basic_type_test {
($trait:ty, $format:ident, $test_value:expr, $expected_len:expr, $expected_ty:ty, $align:literal) => {{
let ctxt = Context::<$trait>::new(EncodingFormat::$format, 1);
let (encoded, fds) = to_bytes_fds(ctxt, &$test_value).unwrap();
let padding = crate::padding_for_n_bytes(1, $align);
assert_eq!(
encoded.len(),
$expected_len + padding,
"invalid encoding using `to_bytes`"
);
let decoded: $expected_ty = from_slice_fds(&encoded, Some(&fds), ctxt).unwrap();
assert!(
decoded == $test_value,
"invalid decoding using `from_slice`"
);
let ctxt = Context::<$trait>::new(EncodingFormat::$format, 0);
let (encoded, _) = to_bytes_fds(ctxt, &$test_value).unwrap();
assert_eq!(
encoded.len(),
$expected_len,
"invalid encoding using `to_bytes`"
);
encoded
}};
($trait:ty, $format:ident, $test_value:expr, $expected_len:expr, $expected_ty:ty, $align:literal, $kind:ident, $expected_value_len:expr) => {{
let encoded = basic_type_test!(
$trait,
$format,
$test_value,
$expected_len,
$expected_ty,
$align
);
let v: Value = $test_value.into();
assert_eq!(v.value_signature(), <$expected_ty>::SIGNATURE_STR);
assert_eq!(v, Value::$kind($test_value));
value_test!(LE, $format, v, $expected_value_len);
let v: $expected_ty = v.try_into().unwrap();
assert_eq!(v, $test_value);
encoded
}};
}
macro_rules! value_test {
($trait:ty, $format:ident, $test_value:expr, $expected_len:expr) => {{
let ctxt = Context::<$trait>::new(EncodingFormat::$format, 0);
let (encoded, fds) = to_bytes_fds(ctxt, &$test_value).unwrap();
assert_eq!(
encoded.len(),
$expected_len,
"invalid encoding using `to_bytes`"
);
let decoded: Value = from_slice_fds(&encoded, Some(&fds), ctxt).unwrap();
assert!(
decoded == $test_value,
"invalid decoding using `from_slice`"
);
encoded
}};
}
fn decode_with_gvariant<B, T>(encoded: B) -> T
where
B: AsRef<[u8]> + Send + 'static,
T: glib::variant::FromVariant,
{
let bytes = Bytes::from_owned(encoded);
let gv = Variant::from_bytes::<T>(&bytes);
gv.get::<T>().unwrap()
}
#[test]
fn u8_value() {
let encoded = basic_type_test!(LE, DBus, 77_u8, 1, u8, 1, U8, 4);
assert_eq!(decode_with_gvariant::<_, u8>(encoded), 77u8);
basic_type_test!(LE, GVariant, 77_u8, 1, u8, 1, U8, 3);
}
#[test]
fn i8_value() {
basic_type_test!(LE, DBus, 77_i8, 2, i8, 2);
basic_type_test!(LE, GVariant, 77_i8, 2, i8, 2);
}
#[test]
fn fd_value() {
basic_type_test!(LE, DBus, Fd::from(42), 4, Fd, 4, Fd, 8);
basic_type_test!(LE, GVariant, Fd::from(42), 4, Fd, 4, Fd, 6);
}
#[test]
fn u16_value() {
let encoded = basic_type_test!(BE, DBus, 0xABBA_u16, 2, u16, 2, U16, 6);
assert_eq!(decode_with_gvariant::<_, u16>(encoded), 0xBAAB_u16);
basic_type_test!(BE, GVariant, 0xABBA_u16, 2, u16, 2, U16, 4);
}
#[test]
fn i16_value() {
let encoded = basic_type_test!(BE, DBus, -0xAB0_i16, 2, i16, 2, I16, 6);
assert_eq!(LE::read_i16(&encoded), 0x50F5_i16);
assert_eq!(decode_with_gvariant::<_, i16>(encoded), 0x50F5_i16);
basic_type_test!(BE, GVariant, -0xAB0_i16, 2, i16, 2, I16, 4);
}
#[test]
fn u32_value() {
let encoded = basic_type_test!(BE, DBus, 0xABBA_ABBA_u32, 4, u32, 4, U32, 8);
assert_eq!(decode_with_gvariant::<_, u32>(encoded), 0xBAAB_BAAB_u32);
basic_type_test!(BE, GVariant, 0xABBA_ABBA_u32, 4, u32, 4, U32, 6);
}
#[test]
fn i32_value() {
let encoded = basic_type_test!(BE, DBus, -0xABBA_AB0_i32, 4, i32, 4, I32, 8);
assert_eq!(LE::read_i32(&encoded), 0x5055_44F5_i32);
assert_eq!(decode_with_gvariant::<_, i32>(encoded), 0x5055_44F5_i32);
basic_type_test!(BE, GVariant, -0xABBA_AB0_i32, 4, i32, 4, I32, 6);
}
#[test]
fn i64_value() {
let encoded = basic_type_test!(BE, DBus, -0xABBA_ABBA_ABBA_AB0_i64, 8, i64, 8, I64, 16);
assert_eq!(LE::read_i64(&encoded), 0x5055_4455_4455_44F5_i64);
assert_eq!(
decode_with_gvariant::<_, i64>(encoded),
0x5055_4455_4455_44F5_i64
);
basic_type_test!(BE, GVariant, -0xABBA_ABBA_ABBA_AB0_i64, 8, i64, 8, I64, 10);
}
#[test]
fn f64_value() {
let encoded = basic_type_test!(BE, DBus, 99999.99999_f64, 8, f64, 8, F64, 16);
assert_eq!(LE::read_f64(&encoded), -5759340900185448e-143);
assert_eq!(
decode_with_gvariant::<_, f64>(encoded),
-5759340900185448e-143
);
basic_type_test!(BE, GVariant, 99999.99999_f64, 8, f64, 8, F64, 10);
}
#[test]
fn str_value() {
let string = String::from("hello world");
basic_type_test!(LE, DBus, string, 16, String, 4);
basic_type_test!(LE, DBus, string, 16, &str, 4);
let encoded = basic_type_test!(LE, GVariant, string, 12, String, 1);
assert_eq!(decode_with_gvariant::<_, String>(encoded), "hello world");
let string = "hello world";
basic_type_test!(LE, DBus, string, 16, &str, 4);
basic_type_test!(LE, DBus, string, 16, String, 4);
let v: Value = string.into();
assert_eq!(v.value_signature(), "s");
assert_eq!(v, Value::new("hello world"));
value_test!(LE, DBus, v, 20);
let encoded = value_test!(LE, GVariant, v, 14);
let bytes = Bytes::from_owned(encoded);
let gv = Variant::from_bytes::<Variant>(&bytes);
let variant = gv.get_variant().unwrap();
assert_eq!(variant.get_str().unwrap(), "hello world");
let v: String = v.try_into().unwrap();
assert_eq!(v, "hello world");
let v: String = v.try_into().unwrap();
assert_eq!(v, "hello world");
basic_type_test!(LE, DBus, 'c', 6, char, 4);
basic_type_test!(LE, GVariant, 'c', 2, char, 1);
let v: Value = "c".into();
assert_eq!(v.value_signature(), "s");
let ctxt = Context::new_dbus(0);
let encoded = to_bytes::<LE, _>(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 10);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
assert_eq!(v, Value::new("c"));
}
#[cfg(feature = "arrayvec")]
#[test]
fn array_string_value() {
let s = ArrayString::<[_; 32]>::from_str("hello world!").unwrap();
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &s).unwrap();
assert_eq!(encoded.len(), 17);
let decoded: ArrayString<[_; 32]> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(&decoded, "hello world!");
}
#[test]
fn signature_value() {
let sig = Signature::try_from("yys").unwrap();
basic_type_test!(LE, DBus, sig, 5, Signature, 1);
let encoded = basic_type_test!(LE, GVariant, sig, 4, Signature, 1);
assert_eq!(decode_with_gvariant::<_, String>(encoded), "yys");
let v: Value = sig.into();
assert_eq!(v.value_signature(), "g");
let encoded = value_test!(LE, DBus, v, 8);
let ctxt = Context::new_dbus(0);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
assert_eq!(v, Value::Signature(Signature::try_from("yys").unwrap()));
let encoded = value_test!(LE, GVariant, v, 6);
let ctxt = Context::new_gvariant(0);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
assert_eq!(v, Value::Signature(Signature::try_from("yys").unwrap()));
}
#[test]
fn object_path_value() {
let o = ObjectPath::try_from("/hello/world").unwrap();
basic_type_test!(LE, DBus, o, 17, ObjectPath, 4);
let encoded = basic_type_test!(LE, GVariant, o, 13, ObjectPath, 1);
assert_eq!(decode_with_gvariant::<_, String>(encoded), "/hello/world");
let v: Value = o.into();
assert_eq!(v.value_signature(), "o");
let encoded = value_test!(LE, DBus, v, 21);
let ctxt = Context::new_dbus(0);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
assert_eq!(
v,
Value::ObjectPath(ObjectPath::try_from("/hello/world").unwrap())
);
let encoded = value_test!(LE, GVariant, v, 15);
let ctxt = Context::new_gvariant(0);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
assert_eq!(
v,
Value::ObjectPath(ObjectPath::try_from("/hello/world").unwrap())
);
}
#[test]
fn unit() {
let ctxt = Context::<BE>::new_dbus(0);
let (encoded, fds) = to_bytes_fds(ctxt, &()).unwrap();
assert_eq!(encoded.len(), 0, "invalid encoding using `to_bytes`");
let decoded: () = from_slice_fds(&encoded, Some(&fds), ctxt).unwrap();
assert_eq!(decoded, (), "invalid decoding using `from_slice`");
}
#[test]
fn array_value() {
let ay = [77u8, 88];
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &ay).unwrap();
assert_eq!(encoded.len(), 2);
let decoded: [u8; 2] = from_slice(&encoded, ctxt).unwrap();
assert_eq!(&decoded, &[77u8, 88]);
#[cfg(feature = "arrayvec")]
let ay = ArrayVec::from([77u8, 88]);
#[cfg(not(feature = "arrayvec"))]
let ay = vec![77u8, 88];
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &ay).unwrap();
assert_eq!(encoded.len(), 6);
#[cfg(feature = "arrayvec")]
let decoded: ArrayVec<[u8; 2]> = from_slice(&encoded, ctxt).unwrap();
#[cfg(not(feature = "arrayvec"))]
let decoded: Vec<u8> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(&decoded.as_slice(), &[77u8, 88]);
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &ay).unwrap();
assert_eq!(gv_encoded.len(), 2);
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<&[u8]>(&bytes);
assert_eq!(variant.n_children(), 2);
assert_eq!(variant.get_child_value(0).get::<u8>().unwrap(), 77);
assert_eq!(variant.get_child_value(1).get::<u8>().unwrap(), 88);
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = ay[..].into();
assert_eq!(v.value_signature(), "ay");
let encoded = to_bytes::<LE, _>(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 10);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
if let Value::Array(array) = v {
assert_eq!(*array.element_signature(), "y");
assert_eq!(array.len(), 2);
assert_eq!(array.get()[0], Value::U8(77));
assert_eq!(array.get()[1], Value::U8(88));
} else {
panic!();
}
let vec = ay.to_vec();
let encoded = to_bytes::<LE, _>(ctxt, &vec).unwrap();
assert_eq!(encoded.len(), 6);
let v: Value = Array::from(&vec).into();
assert_eq!(v.value_signature(), "ay");
let encoded = to_bytes::<LE, _>(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 10);
let at: Vec<u64> = vec![];
let encoded = to_bytes::<LE, _>(ctxt, &at).unwrap();
assert_eq!(encoded.len(), 8);
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &at).unwrap();
assert_eq!(gv_encoded.len(), 0);
let at = from_slice::<LE, Vec<u64>>(&gv_encoded, ctxt).unwrap();
assert_eq!(at.len(), 0);
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = at[..].into();
assert_eq!(v.value_signature(), "at");
let encoded = to_bytes::<LE, _>(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 8);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
if let Value::Array(array) = v {
assert_eq!(*array.element_signature(), "t");
assert_eq!(array.len(), 0);
} else {
panic!();
}
let ctxt = Context::<LE>::new_gvariant(0);
let v: Value = at[..].into();
let gv_encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(gv_encoded.len(), 3);
let v = from_slice::<LE, Value>(&gv_encoded, ctxt).unwrap();
if let Value::Array(array) = v {
assert_eq!(*array.element_signature(), "t");
assert_eq!(array.len(), 0);
} else {
panic!();
}
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<&[&str]>(&bytes);
assert_eq!(variant.n_children(), 0);
let ctxt = Context::<LE>::new_dbus(0);
let as_ = vec!["Hello", "World", "Now", "Bye!"];
let encoded = to_bytes::<LE, _>(ctxt, &as_).unwrap();
assert_eq!(encoded.len(), 45);
let decoded = from_slice::<LE, Vec<&str>>(&encoded, ctxt).unwrap();
assert_eq!(decoded.len(), 4);
assert_eq!(decoded[0], "Hello");
assert_eq!(decoded[1], "World");
let decoded = from_slice::<LE, Vec<String>>(&encoded, ctxt).unwrap();
assert_eq!(decoded.as_slice(), as_.as_slice());
let ctxt = Context::<LE>::new_dbus(14);
let decoded: &str = from_slice(&encoded[14..], ctxt).unwrap();
assert_eq!(decoded, "World");
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = as_[..].into();
assert_eq!(v.value_signature(), "as");
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 49);
let v = from_slice(&encoded, ctxt).unwrap();
if let Value::Array(array) = v {
assert_eq!(*array.element_signature(), "s");
assert_eq!(array.len(), 4);
assert_eq!(array.get()[0], Value::new("Hello"));
assert_eq!(array.get()[1], Value::new("World"));
} else {
panic!();
}
let v: Value = as_[..].into();
let a: Array = v.try_into().unwrap();
let _ve: Vec<String> = a.try_into().unwrap();
let ctxt = Context::<LE>::new_gvariant(0);
let v: Value = as_[..].into();
let gv_encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(gv_encoded.len(), 28);
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
assert_eq!(variant.n_children(), 1);
let decoded: Vec<String> = variant.get_child_value(0).get().unwrap();
assert_eq!(decoded[0], "Hello");
assert_eq!(decoded[1], "World");
let ar = vec![(
u8::max_value(),
u32::max_value(),
(
i64::max_value(),
true,
i64::max_value(),
&["Hello", "World"][..],
),
"hello",
)];
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &ar).unwrap();
assert_eq!(encoded.len(), 78);
let decoded =
from_slice::<LE, Vec<(u8, u32, (i64, bool, i64, Vec<&str>), &str)>>(&encoded, ctxt)
.unwrap();
assert_eq!(decoded.len(), 1);
let r = &decoded[0];
assert_eq!(r.0, u8::max_value());
assert_eq!(r.1, u32::max_value());
let inner_r = &r.2;
assert_eq!(inner_r.0, i64::max_value());
assert_eq!(inner_r.1, true);
assert_eq!(inner_r.2, i64::max_value());
let as_ = &inner_r.3;
assert_eq!(as_.len(), 2);
assert_eq!(as_[0], "Hello");
assert_eq!(as_[1], "World");
assert_eq!(r.3, "hello");
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &ar).unwrap();
assert_eq!(gv_encoded.len(), 54);
let decoded =
from_slice::<LE, Vec<(u8, u32, (i64, bool, i64, Vec<&str>), &str)>>(&gv_encoded, ctxt)
.unwrap();
assert_eq!(decoded.len(), 1);
let r = &decoded[0];
assert_eq!(r.0, u8::max_value());
assert_eq!(r.1, u32::max_value());
let inner_r = &r.2;
assert_eq!(inner_r.0, i64::max_value());
assert_eq!(inner_r.1, true);
assert_eq!(inner_r.2, i64::max_value());
let as_ = &inner_r.3;
assert_eq!(as_.len(), 2);
assert_eq!(as_[0], "Hello");
assert_eq!(as_[1], "World");
assert_eq!(r.3, "hello");
let bytes = Bytes::from_owned(gv_encoded);
let variant =
Variant::from_bytes::<Vec<(u8, u32, (i64, bool, i64, Vec<String>), String)>>(&bytes);
assert_eq!(variant.n_children(), 1);
let r: (u8, u32, (i64, bool, i64, Vec<String>), String) =
variant.get_child_value(0).get().unwrap();
assert_eq!(r.0, u8::max_value());
assert_eq!(r.1, u32::max_value());
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = ar[..].into();
assert_eq!(v.value_signature(), "a(yu(xbxas)s)");
let encoded = to_bytes::<LE, _>(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 94);
let v = from_slice::<LE, Value>(&encoded, ctxt).unwrap();
if let Value::Array(array) = v.clone() {
assert_eq!(*array.element_signature(), "(yu(xbxas)s)");
assert_eq!(array.len(), 1);
let r = &array.get()[0];
if let Value::Structure(r) = r {
let fields = r.fields();
assert_eq!(fields[0], Value::U8(u8::max_value()));
assert_eq!(fields[1], Value::U32(u32::max_value()));
if let Value::Structure(r) = &fields[2] {
let fields = r.fields();
assert_eq!(fields[0], Value::I64(i64::max_value()));
assert_eq!(fields[1], Value::Bool(true));
assert_eq!(fields[2], Value::I64(i64::max_value()));
if let Value::Array(as_) = &fields[3] {
assert_eq!(as_.len(), 2);
assert_eq!(as_.get()[0], Value::new("Hello"));
assert_eq!(as_.get()[1], Value::new("World"));
} else {
panic!();
}
} else {
panic!();
}
assert_eq!(fields[3], Value::new("hello"));
} else {
panic!();
}
} else {
panic!();
}
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(gv_encoded.len(), 68);
let v = from_slice::<LE, Value>(&gv_encoded, ctxt).unwrap();
if let Value::Array(array) = v {
assert_eq!(*array.element_signature(), "(yu(xbxas)s)");
assert_eq!(array.len(), 1);
let r = &array.get()[0];
if let Value::Structure(r) = r {
let fields = r.fields();
assert_eq!(fields[0], Value::U8(u8::max_value()));
assert_eq!(fields[1], Value::U32(u32::max_value()));
if let Value::Structure(r) = &fields[2] {
let fields = r.fields();
assert_eq!(fields[0], Value::I64(i64::max_value()));
assert_eq!(fields[1], Value::Bool(true));
assert_eq!(fields[2], Value::I64(i64::max_value()));
if let Value::Array(as_) = &fields[3] {
assert_eq!(as_.len(), 2);
assert_eq!(as_.get()[0], Value::new("Hello"));
assert_eq!(as_.get()[1], Value::new("World"));
} else {
panic!();
}
} else {
panic!();
}
assert_eq!(fields[3], Value::new("hello"));
} else {
panic!();
}
} else {
panic!();
}
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
assert_eq!(variant.n_children(), 1);
let child: Variant = variant.get_child_value(0);
let r: (u8, u32, (i64, bool, i64, Vec<String>), String) =
child.get_child_value(0).get().unwrap();
assert_eq!(r.0, u8::max_value());
assert_eq!(r.1, u32::max_value());
let rng = thread_rng();
let as_ = vec![
rng.sample_iter(Alphanumeric).take(126).collect::<String>(),
rng.sample_iter(Alphanumeric).take(126).collect::<String>(),
];
let gv_encoded = to_bytes(ctxt, &as_).unwrap();
assert_eq!(gv_encoded.len(), 258);
let bytes = Bytes::from_owned(gv_encoded.clone());
let variant = Variant::from_bytes::<Vec<String>>(&bytes);
assert_eq!(variant.n_children(), 2);
assert_eq!(variant.get_child_value(0).get::<String>().unwrap(), as_[0]);
assert_eq!(variant.get_child_value(1).get::<String>().unwrap(), as_[1]);
let as2 = from_slice::<LE, Vec<String>>(&gv_encoded, ctxt).unwrap();
assert_eq!(as2, as_);
let v = Value::new(vec![Value::new(43), Value::new("bonjour")]);
let av = <Array>::try_from(v).unwrap();
let av = <Vec<Value>>::try_from(av).unwrap();
assert_eq!(av[0], Value::new(43));
assert_eq!(av[1], Value::new("bonjour"));
let vec = vec![1, 2];
let val = Value::new(&vec);
assert_eq!(TryInto::<Vec<i32>>::try_into(val).unwrap(), vec);
}
#[test]
fn struct_value() {
let s: Value = ("a", "b", (1, 2)).into();
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &s).unwrap();
assert_eq!(dbg!(encoded.len()), 40);
let decoded: Value = from_slice(&encoded, ctxt).unwrap();
let s = <Structure>::try_from(decoded).unwrap();
let outer = <(Str, Str, Structure)>::try_from(s).unwrap();
assert_eq!(outer.0, "a");
assert_eq!(outer.1, "b");
let inner = <(i32, i32)>::try_from(outer.2).unwrap();
assert_eq!(inner.0, 1);
assert_eq!(inner.1, 2);
#[derive(Serialize, Deserialize, Type, PartialEq, Debug)]
struct Foo {
val: u32,
}
let foo = Foo { val: 99 };
let v = SerializeValue(&foo);
let encoded = to_bytes(ctxt, &v).unwrap();
let decoded: DeserializeValue<Foo> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded.0, foo);
}
#[test]
fn struct_ref() {
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &(&1u32, &2u32)).unwrap();
let decoded: [u32; 2] = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, [1u32, 2u32]);
}
#[test]
fn dict_value() {
let mut map: HashMap<i64, &str> = HashMap::new();
map.insert(1, "123");
map.insert(2, "456");
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &map).unwrap();
assert_eq!(dbg!(encoded.len()), 40);
let decoded: HashMap<i64, &str> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded[&1], "123");
assert_eq!(decoded[&2], "456");
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &map).unwrap();
assert_eq!(gv_encoded.len(), 30);
let map: HashMap<i64, &str> = from_slice(&gv_encoded, ctxt).unwrap();
assert_eq!(map[&1], "123");
assert_eq!(map[&2], "456");
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<HashMap<i64, &str>>(&bytes);
assert_eq!(variant.n_children(), 2);
let map: HashMap<i64, String> = HashMap::from_variant(&variant).unwrap();
assert_eq!(map[&1], "123");
assert_eq!(map[&2], "456");
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = Dict::from(map).into();
assert_eq!(v.value_signature(), "a{xs}");
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 48);
let dict: Dict = v.try_into().unwrap();
let map: HashMap<i64, String> = dict.try_into().unwrap();
assert_eq!(map[&1], "123");
assert_eq!(map[&2], "456");
let v = from_slice(&encoded, ctxt).unwrap();
if let Value::Dict(dict) = v {
assert_eq!(dict.get::<i64, str>(&1).unwrap().unwrap(), "123");
assert_eq!(dict.get::<i64, str>(&2).unwrap().unwrap(), "456");
} else {
panic!();
}
let mut map: HashMap<&str, &str> = HashMap::new();
map.insert("hi", "1234");
map.insert("world", "561");
let ctxt = Context::<LE>::new_gvariant(0);
let gv_encoded = to_bytes(ctxt, &map).unwrap();
assert_eq!(gv_encoded.len(), 22);
let map: HashMap<&str, &str> = from_slice(&gv_encoded, ctxt).unwrap();
assert_eq!(map["hi"], "1234");
assert_eq!(map["world"], "561");
let bytes = Bytes::from_owned(gv_encoded);
let variant = Variant::from_bytes::<HashMap<&str, &str>>(&bytes);
assert_eq!(variant.n_children(), 2);
let map: HashMap<String, String> = HashMap::from_variant(&variant).unwrap();
assert_eq!(map["hi"], "1234");
assert_eq!(map["world"], "561");
let map: HashMap<&str, &str> = HashMap::new();
let gv_encoded = to_bytes(ctxt, &map).unwrap();
assert_eq!(gv_encoded.len(), 0);
let map: HashMap<&str, &str> = from_slice(&gv_encoded, ctxt).unwrap();
assert_eq!(map.len(), 0);
let ctxt = Context::<LE>::new_dbus(0);
let mut dict = Dict::new(<&str>::signature(), Value::signature());
dict.add("hello", Value::new("there")).unwrap();
dict.add("bye", Value::new("now")).unwrap();
let v: Value = dict.into();
assert_eq!(v.value_signature(), "a{sv}");
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(dbg!(encoded.len()), 68);
let v: Value = from_slice(&encoded, ctxt).unwrap();
if let Value::Dict(dict) = v {
assert_eq!(
*dict.get::<_, Value>("hello").unwrap().unwrap(),
Value::new("there")
);
assert_eq!(
*dict.get::<_, Value>("bye").unwrap().unwrap(),
Value::new("now")
);
let map = <HashMap<String, Value>>::try_from(dict).unwrap();
assert_eq!(map["hello"], Value::new("there"));
assert_eq!(map["bye"], Value::new("now"));
} else {
panic!();
}
#[derive(SerializeDict, DeserializeDict, TypeDict, PartialEq, Debug)]
struct Test {
process_id: Option<u32>,
group_id: Option<u32>,
user: String,
};
let test = Test {
process_id: Some(42),
group_id: None,
user: "me".to_string(),
};
let encoded = to_bytes(ctxt, &test).unwrap();
assert_eq!(encoded.len(), 51);
let decoded: HashMap<&str, Value> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded["process_id"], Value::U32(42));
assert_eq!(decoded["user"], Value::new("me"));
assert!(!decoded.contains_key("group_id"));
let decoded: Test = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, test);
#[derive(SerializeDict, DeserializeDict, TypeDict, PartialEq, Debug)]
struct TestMissing {
process_id: Option<u32>,
group_id: Option<u32>,
user: String,
quota: u8,
};
let decoded: Result<TestMissing> = from_slice(&encoded, ctxt);
assert_eq!(
decoded.unwrap_err(),
Error::Message("missing field `quota`".to_string())
);
#[derive(SerializeDict, DeserializeDict, TypeDict, PartialEq, Debug)]
struct TestSkipUnknown {
process_id: Option<u32>,
group_id: Option<u32>,
};
let _: TestSkipUnknown = from_slice(&encoded, ctxt).unwrap();
#[derive(SerializeDict, DeserializeDict, TypeDict, PartialEq, Debug)]
#[zvariant(deny_unknown_fields)]
struct TestUnknown {
process_id: Option<u32>,
group_id: Option<u32>,
};
let decoded: Result<TestUnknown> = from_slice(&encoded, ctxt);
assert_eq!(
decoded.unwrap_err(),
Error::Message("unknown field `user`, expected `process_id` or `group_id`".to_string())
);
}
#[test]
fn value_value() {
let ctxt = Context::<BE>::new_dbus(0);
let encoded = to_bytes(ctxt, &0xABBA_ABBA_ABBA_ABBA_u64).unwrap();
assert_eq!(encoded.len(), 8);
assert_eq!(LE::read_u64(&encoded), 0xBAAB_BAAB_BAAB_BAAB_u64);
let decoded: u64 = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, 0xABBA_ABBA_ABBA_ABBA);
let ctxt = Context::<LE>::new_dbus(2);
let encoded = to_bytes(ctxt, &0xABBA_ABBA_ABBA_ABBA_u64).unwrap();
assert_eq!(encoded.len(), 14);
let decoded: u64 = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, 0xABBA_ABBA_ABBA_ABBA_u64);
let ctxt = Context::<LE>::new_dbus(0);
let v: Value = 0xFEFE_u64.into();
assert_eq!(v.value_signature(), "t");
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 16);
let v = from_slice(&encoded, ctxt).unwrap();
assert_eq!(v, Value::U64(0xFEFE));
let v = Value::Value(Box::new(v));
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 16);
let v = from_slice(&encoded, ctxt).unwrap();
if let Value::Value(v) = v {
assert_eq!(v.value_signature(), "t");
assert_eq!(*v, Value::U64(0xFEFE));
} else {
panic!();
}
let v: Value = 0xFEFE_u64.into();
let encoded = serde_json::to_string(&v).unwrap();
let v = serde_json::from_str::<Value>(&encoded).unwrap();
assert_eq!(v, Value::U64(0xFEFE));
}
#[test]
fn enums() {
use serde::{Deserialize, Serialize};
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
enum Test {
Unit,
NewType(u8),
Tuple(u8, u64),
Struct { y: u8, t: u64 },
}
let ctxt = Context::<BE>::new_dbus(0);
let signature = "u".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::Unit).unwrap();
assert_eq!(encoded.len(), 4);
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Unit);
let signature = "y".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::NewType(42)).unwrap();
assert_eq!(encoded.len(), 5);
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::NewType(42));
let signature = "(yt)".try_into().unwrap();
let encoded = to_bytes_for_signature(ctxt, &signature, &Test::Tuple(42, 42)).unwrap();
assert_eq!(encoded.len(), 24);
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Tuple(42, 42));
let s = Test::Struct { y: 42, t: 42 };
let encoded = to_bytes_for_signature(ctxt, &signature, &s).unwrap();
assert_eq!(encoded.len(), 24);
let decoded: Test = from_slice_for_signature(&encoded, ctxt, &signature).unwrap();
assert_eq!(decoded, Test::Struct { y: 42, t: 42 });
}
#[test]
fn derive() {
use serde::{Deserialize, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
#[derive(Deserialize, Serialize, Type, PartialEq, Debug)]
struct Struct<'s> {
field1: u16,
field2: i64,
field3: &'s str,
}
assert_eq!(Struct::signature(), "(qxs)");
let s = Struct {
field1: 0xFF_FF,
field2: 0xFF_FF_FF_FF_FF_FF,
field3: "hello",
};
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &s).unwrap();
assert_eq!(encoded.len(), 26);
let decoded: Struct = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, s);
#[derive(Deserialize, Serialize, Type)]
struct UnitStruct;
assert_eq!(UnitStruct::signature(), <()>::signature());
let encoded = to_bytes(ctxt, &UnitStruct).unwrap();
assert_eq!(encoded.len(), 0);
let _: UnitStruct = from_slice(&encoded, ctxt).unwrap();
#[repr(u8)]
#[derive(Deserialize_repr, Serialize_repr, Type, Debug, PartialEq)]
enum Enum {
Variant1,
Variant2,
Variant3,
}
assert_eq!(Enum::signature(), u8::signature());
let encoded = to_bytes(ctxt, &Enum::Variant3).unwrap();
assert_eq!(encoded.len(), 1);
let decoded: Enum = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, Enum::Variant3);
#[repr(i64)]
#[derive(Deserialize_repr, Serialize_repr, Type, Debug, PartialEq)]
enum Enum2 {
Variant1,
Variant2,
Variant3,
}
assert_eq!(Enum2::signature(), i64::signature());
let encoded = to_bytes(ctxt, &Enum2::Variant2).unwrap();
assert_eq!(encoded.len(), 8);
let decoded: Enum2 = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, Enum2::Variant2);
#[derive(Deserialize, Serialize, Type, Debug, PartialEq)]
enum NoReprEnum {
Variant1,
Variant2,
Variant3,
}
assert_eq!(NoReprEnum::signature(), u32::signature());
let encoded = to_bytes(ctxt, &NoReprEnum::Variant2).unwrap();
assert_eq!(encoded.len(), 4);
let decoded: NoReprEnum = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, NoReprEnum::Variant2);
}
#[test]
fn serialized_size() {
let ctxt = Context::<LE>::new_dbus(0);
let l = crate::serialized_size(ctxt, &()).unwrap();
assert_eq!(l, 0);
let stdout = std::io::stdout();
let l = crate::serialized_size_fds(ctxt, &Fd::from(&stdout)).unwrap();
assert_eq!(l, (4, 1));
let l = crate::serialized_size(ctxt, &('a', "abc", &(1_u32, 2))).unwrap();
assert_eq!(l, 24);
let v = vec![1, 2];
let l = crate::serialized_size(ctxt, &('a', "abc", &v)).unwrap();
assert_eq!(l, 28);
}
#[test]
fn option_value() {
let ctxt = Context::<LE>::new_gvariant(0);
let mn = Some(16i16);
let encoded = to_bytes(ctxt, &mn).unwrap();
assert_eq!(encoded.len(), 2);
let decoded: Option<i16> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, mn);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Option<i16>>(&bytes);
assert_eq!(variant.get::<Option<i16>>().unwrap(), mn);
let v: Value = mn.into();
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 5);
let decoded: Value = from_slice(&encoded, ctxt).unwrap();
if let Value::Maybe(maybe) = decoded {
assert_eq!(maybe.get().unwrap(), mn);
} else {
panic!();
}
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
let decoded = variant.get_child_value(0).get::<Option<i16>>().unwrap();
assert_eq!(decoded, mn);
let mn: Option<i16> = None;
let encoded = to_bytes(ctxt, &mn).unwrap();
assert_eq!(encoded.len(), 0);
let decoded: Option<i16> = from_slice(&encoded, ctxt).unwrap();
assert!(decoded.is_none());
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Option<i16>>(&bytes);
assert!(variant.get::<Option<i16>>().unwrap().is_none());
let ms = Some("hello world");
let encoded = to_bytes(ctxt, &ms).unwrap();
assert_eq!(encoded.len(), 13);
let decoded: Option<&str> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, ms);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Option<String>>(&bytes);
assert_eq!(
&variant.get::<Option<String>>().unwrap().unwrap(),
ms.unwrap()
);
let v: Value = ms.into();
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 16);
let decoded: Value = from_slice(&encoded, ctxt).unwrap();
if let Value::Maybe(maybe) = decoded {
assert_eq!(maybe.get::<String>().unwrap().as_deref(), ms);
} else {
panic!();
}
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
let decoded = variant.get_child_value(0).get::<Option<String>>().unwrap();
assert_eq!(decoded.as_deref(), ms);
let ms: Option<&str> = None;
let encoded = to_bytes(ctxt, &ms).unwrap();
assert_eq!(encoded.len(), 0);
let decoded: Option<&str> = from_slice(&encoded, ctxt).unwrap();
assert!(decoded.is_none());
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Option<String>>(&bytes);
assert!(variant.get::<Option<String>>().unwrap().is_none());
let ams = vec![
Some(String::from("hello world")),
Some(String::from("bye world")),
];
let encoded = to_bytes(ctxt, &ams).unwrap();
assert_eq!(encoded.len(), 26);
let decoded: Vec<Option<String>> = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, ams);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Vec<Option<String>>>(&bytes);
let decoded = variant.get::<Vec<Option<String>>>().unwrap();
assert_eq!(decoded, ams);
let v: Value = ams.clone().into();
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 30);
let decoded: Value = from_slice(&encoded, ctxt).unwrap();
assert_eq!(v, decoded);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
let decoded = variant
.get_child_value(0)
.get::<Vec<Option<String>>>()
.unwrap();
assert_eq!(decoded, ams);
let structure: (Option<String>, u64, Option<String>) =
(Some(String::from("hello world")), 42u64, None);
let encoded = to_bytes(ctxt, &structure).unwrap();
assert_eq!(encoded.len(), 25);
let decoded: (Option<String>, u64, Option<String>) = from_slice(&encoded, ctxt).unwrap();
assert_eq!(decoded, structure);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<(Option<String>, u64, Option<String>)>(&bytes);
let decoded = variant
.get::<(Option<String>, u64, Option<String>)>()
.unwrap();
assert_eq!(decoded, structure);
let v: Value = structure.clone().into();
let encoded = to_bytes(ctxt, &v).unwrap();
assert_eq!(encoded.len(), 33);
let decoded: Value = from_slice(&encoded, ctxt).unwrap();
assert_eq!(v, decoded);
let bytes = Bytes::from_owned(encoded);
let variant = Variant::from_bytes::<Variant>(&bytes);
let decoded = variant
.get_child_value(0)
.get::<(Option<String>, u64, Option<String>)>()
.unwrap();
assert_eq!(decoded, structure);
}
#[test]
fn struct_with_hashmap() {
use serde::{Deserialize, Serialize};
let mut hmap = HashMap::new();
hmap.insert("key".into(), "value".into());
#[derive(Type, Deserialize, Serialize, PartialEq, Debug)]
struct Foo {
hmap: HashMap<String, String>,
}
let foo = Foo { hmap };
assert_eq!(Foo::signature(), "(a{ss})");
let ctxt = Context::<LE>::new_dbus(0);
let encoded = to_bytes(ctxt, &(&foo, 1)).unwrap();
let f: Foo = from_slice_fds(&encoded, None, ctxt).unwrap();
assert_eq!(f, foo);
}
#[test]
fn issue_59() {
let ctxt = Context::<LE>::new_dbus(0);
let (encoded, _) = to_bytes_fds(ctxt, &("hello",)).unwrap();
let result: Result<(&str, &str)> = from_slice(&encoded, ctxt);
assert!(result.is_err());
}
#[cfg(feature = "ostree-tests")]
#[test]
fn ostree_de() {
#[derive(Deserialize, Serialize, Type, PartialEq, Debug)]
struct Summary<'a>(Vec<Repo<'a>>, #[serde(borrow)] HashMap<&'a str, Value<'a>>);
#[derive(Deserialize, Serialize, Type, PartialEq, Debug)]
struct Repo<'a>(&'a str, #[serde(borrow)] Metadata<'a>);
#[derive(Deserialize, Serialize, Type, PartialEq, Debug)]
struct Metadata<'a>(u64, Vec<u8>, #[serde(borrow)] HashMap<&'a str, Value<'a>>);
let encoded = std::fs::read("../test-data/flatpak-summary.dump").unwrap();
let ctxt = Context::<LE>::new_gvariant(0);
let _: Summary = from_slice(&encoded, ctxt).unwrap();
}
}