use super::{Bundle, DepScene, Obj, Scene, bundle, named, res_bytes, row, serialized};
#[must_use]
pub fn nested_duplicates() -> Scene {
let inner = |name: &str| {
let cab = serialized(
&[],
&[
Obj::named(1, name, &[]),
Obj::named(3, "x3", &[]),
Obj::asset_bundle(
2,
Bundle {
preload: vec![(0, 3)],
rows: vec![row(&format!("assets/{name}.prefab"), (0, 1), (0, 1))],
..Bundle::default()
},
),
],
);
bundle(&[("CAB-DUP", cab)])
};
Scene {
files: vec![named(
"dup.bundle",
bundle(&[("N1", inner("from-n1")), ("N2", inner("from-n2"))]),
)],
resolver: Vec::new(),
}
}
fn outer_with_inner(cab_o: Vec<u8>, inner: &[(&str, Vec<u8>)]) -> (Vec<u8>, Vec<u8>) {
named(
"o.bundle",
bundle(&[("CAB-O", cab_o), ("INNER", bundle(inner))]),
)
}
#[must_use]
pub fn preload_nested_external() -> Scene {
let f = serialized(
&["archive:/CAB-I/CAB-I", "archive:/O/INNER"],
&[
Obj::named(1, "f1", &[]),
Obj::asset_bundle(
2,
Bundle {
preload: vec![(1, 5), (2, 9), (1, 5)],
rows: vec![row("assets/x.prefab", (0, 3), (0, 1))],
..Bundle::default()
},
),
],
);
let o = serialized(&[], &[Obj::named(7, "o7", &[])]);
let i = serialized(&[], &[Obj::named(5, "i5", &[])]);
Scene {
files: vec![
named("f.bundle", bundle(&[("CAB-F", f)])),
outer_with_inner(o, &[("CAB-I", i)]),
],
resolver: Vec::new(),
}
}
#[must_use]
pub fn resource_in_own_nested() -> Scene {
let o = serialized(&[], &[Obj::streamed(1, "tex", "archive:/O/inner", 0, 4)]);
Scene {
files: vec![named(
"o.bundle",
bundle(&[
("CAB-O", o),
("inner", bundle(&[("inner.resS", res_bytes(8, 40))])),
]),
)],
resolver: Vec::new(),
}
}
#[must_use]
pub fn deref_sibling_nested() -> Scene {
let o = serialized(
&["archive:/O/INNER", "archive:/CAB-I/CAB-I"],
&[Obj::named(7, "o7", &[(1, 5), (2, 5)])],
);
let i = serialized(&[], &[Obj::named(5, "i5", &[])]);
Scene {
files: vec![outer_with_inner(o, &[("CAB-I", i)])],
resolver: Vec::new(),
}
}
#[must_use]
pub fn resource_in_nested_cab() -> Scene {
let i = serialized(
&[],
&[Obj::streamed(1, "tex", "archive:/CAB-I/CAB-I.resS", 0, 4)],
);
Scene {
files: vec![named(
"o.bundle",
bundle(&[(
"INNER",
bundle(&[("CAB-I", i), ("CAB-I.resS", res_bytes(8, 40))]),
)]),
)],
resolver: Vec::new(),
}
}
#[must_use]
pub fn nested_replaced_unread() -> Scene {
let i = serialized(
&[],
&[
Obj::named(5, "i5", &[]),
Obj::asset_bundle(
2,
Bundle {
rows: vec![row("assets/i.prefab", (0, 0), (0, 5))],
..Bundle::default()
},
),
],
);
let p = serialized(&[], &[Obj::named(1, "p1", &[])]);
Scene {
files: vec![
named("o.bundle", bundle(&[("INNER", bundle(&[("CAB-I", i)]))])),
named("p.bundle", bundle(&[("INNER", p)])),
],
resolver: Vec::new(),
}
}
#[must_use]
pub fn nested_reloaded() -> Scene {
let mut scene = resource_in_nested_cab();
let (_, data) = scene.files[0].clone();
scene.files.push(named("o2.bundle", data));
scene
}
#[must_use]
pub fn nested_raw_replaced() -> Scene {
let inner = bundle(&[
("R0.resS", res_bytes(4, 10)),
("R1.resS", res_bytes(4, 20)),
("R2.resS", res_bytes(4, 30)),
]);
Scene {
files: vec![
named("o.bundle", bundle(&[("INNER", inner)])),
named("p.bundle", bundle(&[("INNER", res_bytes(4, 50))])),
],
resolver: Vec::new(),
}
}
#[must_use]
pub fn nested_reloaded_spans() -> Scene {
let i = serialized(
&["archive:/CAB-Z/CAB-Z"],
&[
Obj::named(1, "i1", &[]),
Obj::asset_bundle(
3,
Bundle {
preload: vec![(1, 2)],
rows: vec![row("assets/i.prefab", (0, 1), (0, 1))],
..Bundle::default()
},
),
],
);
let z = serialized(
&[],
&[
Obj::named(2, "z2", &[]),
Obj::named(4, "z4", &[]),
Obj::asset_bundle(
3,
Bundle {
preload: vec![(0, 2)],
rows: vec![row("assets/z.prefab", (0, 1), (0, 4))],
..Bundle::default()
},
),
],
);
let o = bundle(&[("INNER", bundle(&[("CAB-I", i)])), ("CAB-Z", z)]);
Scene {
files: vec![named("o.bundle", o.clone()), named("o2.bundle", o)],
resolver: Vec::new(),
}
}
#[must_use]
pub fn nested_reloaded_spans_raced() -> Scene {
let i = serialized(
&["archive:/CAB-Z/CAB-Z"],
&[
Obj::named(1, "i1", &[]),
Obj::asset_bundle(
3,
Bundle {
preload: vec![(1, 2)],
rows: vec![row("assets/i.prefab", (0, 1), (0, 1))],
..Bundle::default()
},
),
],
);
let z = serialized(
&[],
&[
Obj::named(2, "z2", &[]),
Obj::named(4, "z4", &[]),
Obj::asset_bundle(
3,
Bundle {
preload: vec![(0, 2)],
rows: vec![row("assets/z.prefab", (0, 1), (0, 4))],
..Bundle::default()
},
),
],
);
let o_cab = serialized(&[], &[Obj::named(1, "o1", &[])]);
let j = serialized(&[], &[Obj::named(1, "j1", &[])]);
let o = bundle(&[
("CAB-O", o_cab),
("INNER", bundle(&[("CAB-J", j), ("CAB-I", i)])),
("CAB-Z", z),
]);
Scene {
files: vec![named("o.bundle", o.clone()), named("o2.bundle", o)],
resolver: Vec::new(),
}
}
#[must_use]
pub fn nested_dropped_evicted() -> DepScene {
let f = serialized(&[], &[Obj::named(1, "f1", &[])]);
let d = serialized(
&["archive:/CAB-F/CAB-F"],
&[
Obj::named(1, "d1", &[]),
Obj::asset_bundle(
2,
Bundle {
preload: vec![(1, 1)],
rows: vec![row("assets/d.prefab", (0, 1), (0, 1))],
..Bundle::default()
},
),
],
);
let b = serialized(&[], &[Obj::named(1, "b1", &[])]);
DepScene {
scene: Scene {
files: vec![
named("f.bundle", bundle(&[("CAB-F", f)])),
named("a.bundle", bundle(&[("INNER", bundle(&[("CAB-D", d)]))])),
named("b.bundle", bundle(&[("CAB-B", b)])),
named("p.bundle", bundle(&[("INNER", res_bytes(4, 50))])),
],
resolver: Vec::new(),
},
dependencies: vec![1, 2],
}
}
#[must_use]
pub fn nested_evicted() -> DepScene {
let mut scene = nested_dropped_evicted();
scene.scene.files.truncate(3);
scene
}
#[must_use]
pub fn dependency_reads() -> DepScene {
let d = serialized(
&[
"archive:/CAB-DE/CAB-DE",
"archive:/CAB-E/CAB-E",
"archive:/CAB-R/CAB-R",
],
&[
Obj::named(1, "d1", &[(1, 7), (2, 1), (3, 1)]),
Obj::streamed(2, "dtex", "archive:/CAB-D/CAB-D.resS", 4, 8),
Obj::streamed(3, "etex", "archive:/CAB-E/CAB-E.resS", 2, 4),
Obj::streamed(4, "xtex", "archive:/CAB-X/CAB-X.resS", 1, 3),
],
);
let n = serialized(
&["archive:/CAB-NE/CAB-NE", "archive:/CAB-E/CAB-E"],
&[
Obj::named(1, "n1", &[(1, 3), (2, 1)]),
Obj::streamed(2, "ntex", "archive:/CAB-N/CAB-N.resS", 2, 6),
],
);
DepScene {
scene: Scene {
files: vec![
named(
"d.bundle",
bundle(&[
("CAB-D", d),
("CAB-D.resS", res_bytes(64, 7)),
("CAB-DE", serialized(&[], &[Obj::named(7, "de7", &[])])),
]),
),
named(
"n.bundle",
bundle(&[(
"INNER",
bundle(&[
("CAB-N", n),
("CAB-N.resS", res_bytes(32, 40)),
("CAB-NE", serialized(&[], &[Obj::named(3, "ne3", &[])])),
]),
)]),
),
named(
"e.bundle",
bundle(&[
("CAB-E", serialized(&[], &[Obj::named(1, "e1", &[])])),
("CAB-E.resS", res_bytes(16, 90)),
]),
),
],
resolver: vec![
named("cab-r", serialized(&[], &[Obj::named(1, "r1", &[])])),
named("CAB-X.resS", bundle(&[("CAB-X.resS", res_bytes(8, 120))])),
],
},
dependencies: vec![0, 1, 2],
}
}
#[must_use]
pub fn nested_between_loads() -> Scene {
let plain = |name: &str| serialized(&[], &[Obj::named(1, name, &[])]);
let z = serialized(
&[],
&[
Obj::named(5, "z5", &[]),
Obj::named(7, "z7", &[]),
Obj::asset_bundle(
2,
Bundle {
preload: vec![(0, 7)],
rows: vec![row("assets/z.prefab", (0, 1), (0, 5))],
..Bundle::default()
},
),
],
);
let e0 = serialized(&[], &[Obj::named(3, "e0", &[])]);
Scene {
files: vec![
named("a.bundle", bundle(&[("n", plain("a1"))])),
named(
"c.bundle",
bundle(&[("e0", e0), ("n", bundle(&[("CAB-Z", z)]))]),
),
named("b.bundle", bundle(&[("n", plain("b1"))])),
],
resolver: Vec::new(),
}
}