cuprate/net/epee-encoding/tests/flattened.rs
hinto-janai 354ac9c2f6
Add typos + cargo doc CI (#32)
* ci: add separate `typo` job

* add `typos.toml` for false positives

* fix all typos

* ci: add `cargo doc` step

* fix doc errors

* contributing.md: update passing CI steps

* fix more typos, add exception to `cryptonight/`

* ci: move `cargo doc` step within `ci` job

It needs dependencies.

* ci: add https://github.com/Cuprate/cuprate/pull/63

* test-utils: fix typo

* ci: switch `rustup update` and switch order

* ci: only update rust on unix

* ci: set `RUSTDOCFLAGS` env earlier

* ci: only run `cargo doc` on linux

* ci: remove `bash` on `cargo doc`

* ci: remove `--all-targets`

We now have the target OS's in CI, no need to compile for each.

* contributing.md: update ci steps

* ci: add `--all-targets` back to clippy, build

* update contributing.md
2024-02-15 16:03:04 +00:00

102 lines
1.5 KiB
Rust

use epee_encoding::{epee_object, from_bytes, to_bytes};
struct Child {
val: u64,
val2: Vec<u8>,
}
epee_object!(
Child,
val: u64,
val2: Vec<u8>,
);
struct Parent {
child: Child,
h: f64,
}
epee_object!(
Parent,
h: f64,
!flatten:
child: Child,
);
#[derive(Clone)]
struct ParentChild {
h: f64,
val: u64,
val2: Vec<u8>,
}
epee_object!(
ParentChild,
h: f64,
val: u64,
val2: Vec<u8>,
);
#[test]
fn epee_flatten() {
let val2 = ParentChild {
h: 38.9,
val: 94,
val2: vec![4, 5],
};
let mut bytes = to_bytes(val2.clone()).unwrap();
let val: Parent = from_bytes(&mut bytes).unwrap();
assert_eq!(val.child.val2, val2.val2);
assert_eq!(val.child.val, val2.val);
assert_eq!(val.h, val2.h);
}
#[derive(Debug, Default, Clone, PartialEq)]
struct Child1 {
val: u64,
val2: Vec<u8>,
}
epee_object!(
Child1,
val: u64,
val2: Vec<u8>,
);
#[derive(Debug, Default, Clone, PartialEq)]
struct Child2 {
buz: u16,
fiz: String,
}
epee_object!(
Child2,
buz: u16,
fiz: String,
);
#[derive(Debug, Default, Clone, PartialEq)]
struct Parent12 {
child1: Child1,
child2: Child2,
h: f64,
}
epee_object!(
Parent12,
h: f64,
!flatten:
child1: Child1,
child2: Child2,
);
#[test]
fn epee_double_flatten() {
let val = Parent12::default();
let mut bytes = to_bytes(val.clone()).unwrap();
let val1: Parent12 = from_bytes(&mut bytes).unwrap();
assert_eq!(val, val1);
}