use rspack_cacheable::{cacheable, to_bytes, with::Inline};

#[cacheable]
struct Data {
    block1: String
}

#[cacheable]
struct DataRef<'a> {
    #[cacheable(with=Inline)]
    block1: &'a String
}

let data = Data {
    block1: "block1".into()
}
let data_ref = DataRef {
    block1: &data.block1
}
assert_eq!(to_bytes(&data, &()), to_bytes(&data_ref, &()));

use rspack_cacheable::{
  cacheable, from_bytes, to_bytes,
  with::{AsTuple2, Inline},
};

#[cacheable]
#[derive(Debug, PartialEq, Eq)]
struct Person {
  name: String,
  content: (String, String),
}

#[cacheable(as=Person)]
struct PersonRef<'a> {
  #[rkyv(with=Inline)]
  name: &'a String,
  #[rkyv(with=AsTuple2<Inline, Inline>)]
  content: (&'a String, &'a String),
}

#[test]
fn as_attr() {
  let a = Person {
    name: "abc".into(),
    content: ("a".into(), "b".into()),
  };
  let a_ref = PersonRef {
    name: &a.name,
    content: (&a.content.0, &a.content.1),
  };
  // use a_ref to serialize
  let bytes = to_bytes(&a_ref, &()).unwrap();
  // deserialize to Person
  let deserialize_a: Person = from_bytes(&bytes, &()).unwrap();
  assert_eq!(a, deserialize_a);
}