use std::sync::Arc;
use super::{
Packed, ResolvedVersion, UnityVersion, VersionError, VersionPolicy, VersionSource,
resolve_bundle, resolve_serialized,
};
use crate::budget::{Reservation, Unbounded};
use crate::error::{Error, LimitKind};
use crate::limits::{Charge, Limits, Meter};
use crate::raw::RawStr;
#[test]
fn the_chains_take_the_files_string_so_a_version_keeps_it_uncopied() {
let _: fn(&RawStr) -> Result<UnityVersion, VersionError> = UnityVersion::parse;
let _: fn(&RawStr, &VersionPolicy, &mut Charge) -> Result<ResolvedVersion, Error> =
resolve_bundle;
let _: fn(
&RawStr,
Option<&RawStr>,
&VersionPolicy,
&mut Charge,
) -> Result<ResolvedVersion, Error> = resolve_serialized;
}
#[test]
fn a_versions_heap_is_its_big_packed_integer_only() {
let file = bytes::Bytes::from(vec![b'7'; 32_767]);
let shared = UnityVersion {
raw: RawStr::from_shared(file.clone()),
packed: Packed::from_u128(1),
};
assert_eq!(shared.heap_bytes(), 0, "the raw string is the file's");
assert_eq!(shared.raw().as_bytes().as_ptr(), file.as_ptr());
let big = UnityVersion {
raw: RawStr::default(),
packed: Packed::from_limbs(&[1, 2, 3]),
};
assert_eq!(big.heap_bytes(), 24);
assert_eq!(big.packed_u64(), None);
}
#[test]
fn a_tpk_version_round_trips_and_orders_as_python_ints() {
let v2022 = (2022u64 << 48) | (3 << 32) | (3 << 8) | 1;
let v2019 = (2019u64 << 48) | (4 << 32) | (15 << 16) | (3 << 8) | 1;
let a = UnityVersion::from_packed(v2022);
let b = UnityVersion::from_packed(v2019);
assert_eq!(a.packed_u64(), Some(v2022));
assert!(b < a);
assert_eq!(a, UnityVersion::from_packed(v2022));
assert!(a.raw().is_empty());
let mut v = vec![a.clone(), b.clone()];
v.sort();
assert_eq!(v, [b, a]);
}
fn charge_on(work: u64) -> Charge {
let limits = Limits {
max_decode_work: work,
..Limits::default()
};
Charge::zero(&Meter::for_input(
&limits,
Arc::new(Unbounded),
Reservation::Input,
))
}
fn counted(s: &str) -> (u64, Result<Result<UnityVersion, VersionError>, Error>) {
let mut charge = charge_on(u64::MAX);
let got = UnityVersion::parse_charged(&RawStr::from(s), &mut charge);
(charge.meter().decoded(), got)
}
fn zeros_major() -> String {
format!("{}1.2.3f4", "0".repeat(4299))
}
fn nines_major() -> String {
format!("{}.0.0f1", "9".repeat(4300))
}
#[test]
fn a_versions_packing_counts_the_limbs_it_holds_as_the_inputs_work() {
let (work, got) = counted("2022.3.0f1");
assert_eq!(work, 10 + 9 * 8);
let v = got.unwrap().unwrap();
assert_eq!(
v.packed_u64(),
Some((2022 << 48) | (3 << 32) | (3 << 8) | 1)
);
let (work, got) = counted(&zeros_major());
assert_eq!(work, 6_194);
assert_eq!(
got.unwrap().unwrap().packed_u64(),
Some((1 << 48) | (2 << 32) | (3 << 16) | (3 << 8) | 4)
);
assert!(
work < 2 * 4_306,
"{work}: a string of 4,306 bytes whose value is small"
);
let (work, got) = counted(&nines_major());
assert_eq!(work, 211_210);
assert!(
work < 227 * 226 * 8,
"{work}: no fewer limbs than the fixed array's"
);
assert!(work < 50 * 4_306, "{work}: under 50 a byte");
assert_eq!(got.unwrap().unwrap().heap_bytes(), 224 * 8);
}
#[test]
fn a_refused_step_stops_the_packing() {
let s = RawStr::from(zeros_major().as_str());
let mut charge = charge_on(6_194);
assert!(matches!(
UnityVersion::parse_charged(&s, &mut charge),
Ok(Ok(_))
));
let mut charge = charge_on(6_193);
let got = UnityVersion::parse_charged(&s, &mut charge);
assert!(
matches!(&got, Err(Error::Limit(l)) if l.kind() == LimitKind::DecodeWork),
"{got:?}"
);
assert_eq!(
charge.meter().decoded(),
6_194 - 8,
"a refused step that scanned nothing counts nothing"
);
assert!(charge.meter().work_used_up().is_none());
let mut charge = charge_on(1_000);
let got = UnityVersion::parse_charged(&s, &mut charge);
assert!(
matches!(&got, Err(Error::Limit(l)) if l.kind() == LimitKind::DecodeWork),
"{got:?}"
);
let work = charge.meter().decoded();
assert_eq!(work, 37 * (19 + 8) + 19, "the refused step's bytes count");
assert!(
charge.meter().work_used_up().is_some(),
"{work}: the refused step's scan takes the work past the allowance"
);
assert!(UnityVersion::parse(&s).is_ok());
}
fn big_major() -> RawStr {
RawStr::from(format!("1{}.0.0f1", "0".repeat(40)).as_str())
}
#[test]
fn the_chains_charge_a_big_versions_limbs_to_the_handle() {
let policy = VersionPolicy::default();
let mut charge = charge_on(u64::MAX);
let got = resolve_serialized(&big_major(), None, &policy, &mut charge).unwrap();
assert_eq!(got.version.heap_bytes(), 24);
assert_eq!(charge.bytes(), 32);
assert_eq!(charge.meter().used(), 32);
let dropped = RawStr::from("87112285931760246646623899502532662132736.0.0f1");
let policy = VersionPolicy {
fallback: Some(RawStr::from("2020.1.0f1")),
..VersionPolicy::default()
};
let mut charge = charge_on(u64::MAX);
let got = resolve_bundle(&dropped, &policy, &mut charge).unwrap();
assert_eq!(got.source, VersionSource::Fallback);
assert_eq!(charge.bytes(), 0, "the dropped version's limbs");
assert!(charge.meter().decoded() > 0);
let forced = UnityVersion::parse(&big_major()).unwrap();
let policy = VersionPolicy {
force_bundle: Some(forced),
..VersionPolicy::default()
};
let mut charge = charge_on(u64::MAX);
let got = resolve_bundle(&RawStr::from("2020.1.0f1"), &policy, &mut charge).unwrap();
assert_eq!(got.source, VersionSource::Forced);
assert_eq!(charge.bytes(), 32);
}