1097 lines
44 KiB
Rust
1097 lines
44 KiB
Rust
//! Exact Rust translations of `AttachCommandTests` and `AttachAllCommandTests`.
|
|
|
|
use libremetaverse_compat_tests::block_on;
|
|
use libremetaverse_compat_tests::rlv_support::{
|
|
AttachmentCall, RlvHarness, SampleInventoryTree, guid,
|
|
};
|
|
use libremetaverse_rlv::{InventoryMap, RlvAttachmentPoint, RlvWearableType};
|
|
|
|
const BUSINESS: &str = "b0000000-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
|
|
const HAPPY: &str = "b1111111-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
|
|
const RETRO: &str = "b2222222-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
|
|
const PARTY: &str = "d0000000-dddd-4ddd-8ddd-dddddddddddd";
|
|
const FANCY: &str = "d1111111-dddd-4ddd-8ddd-dddddddddddd";
|
|
const GLASSES: &str = "c1111111-cccc-4ccc-8ccc-cccccccccccc";
|
|
const PRIM1: &str = "11111111-0001-4aaa-8aaa-ffffffffffff";
|
|
const PRIM2: &str = "11111111-0002-4aaa-8aaa-ffffffffffff";
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum AttachSetup {
|
|
Default,
|
|
AlreadyAttached,
|
|
PositionFromFolder,
|
|
AddFolder,
|
|
PrivateParent,
|
|
HiddenSubfolder,
|
|
RecursiveAddFolder,
|
|
PrivateSource,
|
|
ThisDefault,
|
|
ThisById,
|
|
ThisAddFolder,
|
|
ThisFolderPoint,
|
|
ThisHidden,
|
|
ThisAttachmentPoint,
|
|
ThisWearable,
|
|
AllThis,
|
|
AllThisHidden,
|
|
AllThisAddFolder,
|
|
AllThisAttachmentPoint,
|
|
AllThisWearable,
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
fn run(command: &str, path: &str, setup: AttachSetup) -> Vec<AttachmentCall> {
|
|
let h = RlvHarness::new().expect("RlvService constructor");
|
|
let mut tree = SampleInventoryTree::build().unwrap();
|
|
match setup {
|
|
AttachSetup::Default => {}
|
|
AttachSetup::AlreadyAttached => {
|
|
tree.business_pants
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Groin)));
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.retro_pants
|
|
.set_worn_on(Some(Some(RlvWearableType::Pants)));
|
|
}
|
|
AttachSetup::PositionFromFolder => {
|
|
tree.hats.set_name("Hats (spine)".into());
|
|
tree.fancy_hat.set_name("Fancy Hat (skull)".into());
|
|
}
|
|
AttachSetup::AddFolder => tree.hats.set_name("+Hats".into()),
|
|
AttachSetup::PrivateParent => tree.clothing.set_name(".clothing".into()),
|
|
AttachSetup::HiddenSubfolder => tree.hats.set_name(".hats".into()),
|
|
AttachSetup::RecursiveAddFolder => tree.hats.set_name("+hats".into()),
|
|
AttachSetup::PrivateSource => tree.clothing.set_name(".auto_attach".into()),
|
|
AttachSetup::ThisDefault => {
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisById | AttachSetup::AllThis => {
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisAddFolder => {
|
|
tree.clothing.set_name("+clothing".into());
|
|
tree.business_pants
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Pelvis)));
|
|
tree.business_pants
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisFolderPoint => {
|
|
tree.party_hat.set_name("Party Hat".into());
|
|
tree.hats.set_name("(skull) hats".into());
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisHidden => {
|
|
tree.hats.set_name(".hats".into());
|
|
tree.fancy_hat.set_name("Fancy Hat (chin)".into());
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisAttachmentPoint => {
|
|
tree.happy_shirt.set_name("Happy Shirt (spine)".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Spine)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
tree.party_hat.set_name("Party Hat (spine)".into());
|
|
tree.party_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Spine)));
|
|
tree.party_hat.set_attached_prim_id(Some(Some(guid(PRIM2))));
|
|
}
|
|
AttachSetup::ThisWearable => {
|
|
tree.watch.set_worn_on(Some(Some(RlvWearableType::Tattoo)));
|
|
tree.retro_pants
|
|
.set_worn_on(Some(Some(RlvWearableType::Tattoo)));
|
|
}
|
|
AttachSetup::AllThisHidden => {
|
|
tree.hats.set_name(".hats".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::AllThisAddFolder => {
|
|
tree.hats.set_name("+hats".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::AllThisAttachmentPoint => {
|
|
tree.happy_shirt.set_name("Happy Shirt (skull)".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Skull)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
tree.watch.set_name("Watch (skull)".into());
|
|
tree.watch
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Skull)));
|
|
tree.watch.set_attached_prim_id(Some(Some(guid(PRIM2))));
|
|
}
|
|
AttachSetup::AllThisWearable => {
|
|
tree.retro_pants
|
|
.set_worn_on(Some(Some(RlvWearableType::Tattoo)));
|
|
}
|
|
}
|
|
h.queries.lock().unwrap().inventory_map = Some(InventoryMap::new(tree.root, vec![]).unwrap());
|
|
block_on(h.process(&format!("@{command}:{path}=force"))).unwrap();
|
|
let mut calls = h.actions.lock().unwrap().attachments[0].clone();
|
|
calls.sort_by_key(|call| call.item_id.0);
|
|
calls
|
|
}
|
|
|
|
fn run_this(
|
|
command: &str,
|
|
argument: Option<&str>,
|
|
setup: AttachSetup,
|
|
from_item: bool,
|
|
) -> Vec<AttachmentCall> {
|
|
let h = RlvHarness::new().expect("RlvService constructor");
|
|
let mut tree = SampleInventoryTree::build().unwrap();
|
|
match setup {
|
|
AttachSetup::ThisDefault => {
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisById | AttachSetup::AllThis => {
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisAddFolder => {
|
|
tree.clothing.set_name("+clothing".into());
|
|
tree.business_pants
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Pelvis)));
|
|
tree.business_pants
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisFolderPoint => {
|
|
tree.party_hat.set_name("Party Hat".into());
|
|
tree.hats.set_name("(skull) hats".into());
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisHidden => {
|
|
tree.hats.set_name(".hats".into());
|
|
tree.fancy_hat.set_name("Fancy Hat (chin)".into());
|
|
tree.fancy_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chin)));
|
|
tree.fancy_hat.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::ThisAttachmentPoint => {
|
|
tree.happy_shirt.set_name("Happy Shirt (spine)".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Spine)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
tree.party_hat.set_name("Party Hat (spine)".into());
|
|
tree.party_hat
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Spine)));
|
|
tree.party_hat.set_attached_prim_id(Some(Some(guid(PRIM2))));
|
|
}
|
|
AttachSetup::ThisWearable => {
|
|
tree.watch.set_worn_on(Some(Some(RlvWearableType::Tattoo)));
|
|
tree.retro_pants
|
|
.set_worn_on(Some(Some(RlvWearableType::Tattoo)));
|
|
}
|
|
AttachSetup::AllThisHidden => {
|
|
tree.hats.set_name(".hats".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::AllThisAddFolder => {
|
|
tree.hats.set_name("+hats".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Chest)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
}
|
|
AttachSetup::AllThisAttachmentPoint => {
|
|
tree.happy_shirt.set_name("Happy Shirt (skull)".into());
|
|
tree.happy_shirt
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Skull)));
|
|
tree.happy_shirt
|
|
.set_attached_prim_id(Some(Some(guid(PRIM1))));
|
|
tree.watch.set_name("Watch (skull)".into());
|
|
tree.watch
|
|
.set_attached_to(Some(Some(RlvAttachmentPoint::Skull)));
|
|
tree.watch.set_attached_prim_id(Some(Some(guid(PRIM2))));
|
|
}
|
|
AttachSetup::AllThisWearable => tree
|
|
.retro_pants
|
|
.set_worn_on(Some(Some(RlvWearableType::Tattoo))),
|
|
_ => unreachable!(),
|
|
}
|
|
h.queries.lock().unwrap().inventory_map = Some(InventoryMap::new(tree.root, vec![]).unwrap());
|
|
let message = argument.map_or_else(
|
|
|| format!("@{command}=force"),
|
|
|value| format!("@{command}:{value}=force"),
|
|
);
|
|
if from_item {
|
|
block_on(h.process_from(&message, PRIM1, "attached item")).unwrap();
|
|
} else {
|
|
block_on(h.process(&message)).unwrap();
|
|
}
|
|
let mut calls = h.actions.lock().unwrap().attachments[0].clone();
|
|
calls.sort_by_key(|call| call.item_id.0);
|
|
calls
|
|
}
|
|
|
|
fn call(id: &str, point: RlvAttachmentPoint, replace: bool) -> AttachmentCall {
|
|
AttachmentCall {
|
|
item_id: guid(id),
|
|
point,
|
|
replace,
|
|
}
|
|
}
|
|
|
|
fn hats(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(PARTY, RlvAttachmentPoint::Spine, replace),
|
|
call(FANCY, RlvAttachmentPoint::Chin, replace),
|
|
]
|
|
}
|
|
|
|
fn clothing(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(HAPPY, RlvAttachmentPoint::Default, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
]
|
|
}
|
|
|
|
fn recursive(replace: bool, hats_replace: bool) -> Vec<AttachmentCall> {
|
|
let mut expected = clothing(replace);
|
|
expected.extend(hats(hats_replace));
|
|
expected
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce::case:5e4fd9176ccab2f0 2ecd1c4e8f6238ac0e1274053bcc512d08767c61a0532bbd321d1c8b15c94d6d translated
|
|
#[test]
|
|
fn attach_hats() {
|
|
assert_eq!(
|
|
run("attach", "Clothing/Hats", AttachSetup::Default),
|
|
hats(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce::case:1112c98c6420210d 2ecd1c4e8f6238ac0e1274053bcc512d08767c61a0532bbd321d1c8b15c94d6d translated
|
|
#[test]
|
|
fn attach_over_or_replace_hats() {
|
|
assert_eq!(
|
|
run("attachoverorreplace", "Clothing/Hats", AttachSetup::Default),
|
|
hats(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce::case:0dd9d8fadf48e313 2ecd1c4e8f6238ac0e1274053bcc512d08767c61a0532bbd321d1c8b15c94d6d translated
|
|
#[test]
|
|
fn attach_over_hats() {
|
|
assert_eq!(
|
|
run("attachover", "Clothing/Hats", AttachSetup::Default),
|
|
hats(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_WithClothing::case:5e4fd9176ccab2f0 1bbd8cf1f00311fc656ca6c05d60ed033c6a69d59d4ff69d876f50f9d48645a3 translated
|
|
#[test]
|
|
fn attach_clothing() {
|
|
assert_eq!(
|
|
run("attach", "Clothing", AttachSetup::Default),
|
|
clothing(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_WithClothing::case:1112c98c6420210d 1bbd8cf1f00311fc656ca6c05d60ed033c6a69d59d4ff69d876f50f9d48645a3 translated
|
|
#[test]
|
|
fn attach_over_or_replace_clothing() {
|
|
assert_eq!(
|
|
run("attachoverorreplace", "Clothing", AttachSetup::Default),
|
|
clothing(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_WithClothing::case:0dd9d8fadf48e313 1bbd8cf1f00311fc656ca6c05d60ed033c6a69d59d4ff69d876f50f9d48645a3 translated
|
|
#[test]
|
|
fn attach_over_clothing() {
|
|
assert_eq!(
|
|
run("attachover", "Clothing", AttachSetup::Default),
|
|
clothing(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AlreadyAttached::case:2a7ad8f0a57b741d 751483b13ff87bf258c3aec671ff6a8c9b34e8126f7e877982065d28ef426385 translated
|
|
#[test]
|
|
fn attach_skips_already_attached() {
|
|
assert!(run("attach", "Clothing", AttachSetup::AlreadyAttached).is_empty());
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AlreadyAttached::case:da775b6e5cf13e70 751483b13ff87bf258c3aec671ff6a8c9b34e8126f7e877982065d28ef426385 translated
|
|
#[test]
|
|
fn attach_over_or_replace_skips_already_attached() {
|
|
assert!(
|
|
run(
|
|
"attachoverorreplace",
|
|
"Clothing",
|
|
AttachSetup::AlreadyAttached
|
|
)
|
|
.is_empty()
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AlreadyAttached::case:e59967ec103647cc 751483b13ff87bf258c3aec671ff6a8c9b34e8126f7e877982065d28ef426385 translated
|
|
#[test]
|
|
fn attach_over_skips_already_attached() {
|
|
assert!(run("attachover", "Clothing", AttachSetup::AlreadyAttached).is_empty());
|
|
}
|
|
|
|
fn positioned(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(PARTY, RlvAttachmentPoint::Spine, replace),
|
|
call(FANCY, RlvAttachmentPoint::Skull, replace),
|
|
]
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_PositionFromFolderName::case:5e4fd9176ccab2f0 6a34c794669e596b982f5050071502e43061053677b44536f60847d4c3798634 translated
|
|
#[test]
|
|
fn attach_uses_position_from_folder_name() {
|
|
assert_eq!(
|
|
run(
|
|
"attach",
|
|
"Clothing/Hats (spine)",
|
|
AttachSetup::PositionFromFolder
|
|
),
|
|
positioned(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_PositionFromFolderName::case:1112c98c6420210d 6a34c794669e596b982f5050071502e43061053677b44536f60847d4c3798634 translated
|
|
#[test]
|
|
fn attach_over_or_replace_uses_position_from_folder_name() {
|
|
assert_eq!(
|
|
run(
|
|
"attachoverorreplace",
|
|
"Clothing/Hats (spine)",
|
|
AttachSetup::PositionFromFolder
|
|
),
|
|
positioned(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_PositionFromFolderName::case:0dd9d8fadf48e313 6a34c794669e596b982f5050071502e43061053677b44536f60847d4c3798634 translated
|
|
#[test]
|
|
fn attach_over_uses_position_from_folder_name() {
|
|
assert_eq!(
|
|
run(
|
|
"attachover",
|
|
"Clothing/Hats (spine)",
|
|
AttachSetup::PositionFromFolder
|
|
),
|
|
positioned(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_FolderNameSpecifiesToAddInsteadOfReplace::case:2a7ad8f0a57b741d 5c09150744493c62b8b5c0ec139b6580bb74fe618b1a111b7a1ce583e8fa82e1 translated
|
|
#[test]
|
|
fn attach_honors_add_folder() {
|
|
assert_eq!(
|
|
run("attach", "Clothing/+Hats", AttachSetup::AddFolder),
|
|
hats(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_FolderNameSpecifiesToAddInsteadOfReplace::case:da775b6e5cf13e70 5c09150744493c62b8b5c0ec139b6580bb74fe618b1a111b7a1ce583e8fa82e1 translated
|
|
#[test]
|
|
fn attach_over_or_replace_honors_add_folder() {
|
|
assert_eq!(
|
|
run(
|
|
"attachoverorreplace",
|
|
"Clothing/+Hats",
|
|
AttachSetup::AddFolder
|
|
),
|
|
hats(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_FolderNameSpecifiesToAddInsteadOfReplace::case:e59967ec103647cc 5c09150744493c62b8b5c0ec139b6580bb74fe618b1a111b7a1ce583e8fa82e1 translated
|
|
#[test]
|
|
fn attach_over_honors_add_folder() {
|
|
assert_eq!(
|
|
run("attachover", "Clothing/+Hats", AttachSetup::AddFolder),
|
|
hats(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AttachPrivateParentFolder::case:5e4fd9176ccab2f0 268a375256333f2986ac68c5a357042b424f867585ef5a954328f9333b62007c translated
|
|
#[test]
|
|
fn attach_allows_private_parent() {
|
|
assert_eq!(
|
|
run("attach", ".clothing/Hats", AttachSetup::PrivateParent),
|
|
hats(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AttachPrivateParentFolder::case:1112c98c6420210d 268a375256333f2986ac68c5a357042b424f867585ef5a954328f9333b62007c translated
|
|
#[test]
|
|
fn attach_over_or_replace_allows_private_parent() {
|
|
assert_eq!(
|
|
run(
|
|
"attachoverorreplace",
|
|
".clothing/Hats",
|
|
AttachSetup::PrivateParent
|
|
),
|
|
hats(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachCommandTests.cs::AttachCommandTests.AttachForce_AttachPrivateParentFolder::case:0dd9d8fadf48e313 268a375256333f2986ac68c5a357042b424f867585ef5a954328f9333b62007c translated
|
|
#[test]
|
|
fn attach_over_allows_private_parent() {
|
|
assert_eq!(
|
|
run("attachover", ".clothing/Hats", AttachSetup::PrivateParent),
|
|
hats(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive::case:eee2b1b757fc196e 17a84542635b76f4f806126ab170d43441ad00b9b91650aa1164909de9692671 translated
|
|
#[test]
|
|
fn attach_all_recursive() {
|
|
assert_eq!(
|
|
run("attachall", "Clothing", AttachSetup::Default),
|
|
recursive(true, true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive::case:e6bc1820d9335b07 17a84542635b76f4f806126ab170d43441ad00b9b91650aa1164909de9692671 translated
|
|
#[test]
|
|
fn attach_all_over_or_replace_recursive() {
|
|
assert_eq!(
|
|
run("attachalloverorreplace", "Clothing", AttachSetup::Default),
|
|
recursive(true, true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive::case:fb63a8c8c9b75b99 17a84542635b76f4f806126ab170d43441ad00b9b91650aa1164909de9692671 translated
|
|
#[test]
|
|
fn attach_all_over_recursive() {
|
|
assert_eq!(
|
|
run("attachallover", "Clothing", AttachSetup::Default),
|
|
recursive(false, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_WithHiddenSubfolder::case:eee2b1b757fc196e f2e3209b5a1a655a846e7f19801ed118a6dd303edeab705480aaf03959a383e4 translated
|
|
#[test]
|
|
fn attach_all_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run("attachall", "Clothing", AttachSetup::HiddenSubfolder),
|
|
clothing(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_WithHiddenSubfolder::case:e6bc1820d9335b07 f2e3209b5a1a655a846e7f19801ed118a6dd303edeab705480aaf03959a383e4 translated
|
|
#[test]
|
|
fn attach_all_over_or_replace_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run(
|
|
"attachalloverorreplace",
|
|
"Clothing",
|
|
AttachSetup::HiddenSubfolder
|
|
),
|
|
clothing(true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_WithHiddenSubfolder::case:fb63a8c8c9b75b99 f2e3209b5a1a655a846e7f19801ed118a6dd303edeab705480aaf03959a383e4 translated
|
|
#[test]
|
|
fn attach_all_over_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run("attachallover", "Clothing", AttachSetup::HiddenSubfolder),
|
|
clothing(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:eee2b1b757fc196e 6164ae5589e5a684637e9c85dd04e5e4c439c541be45b5ae2228e5c5edb2b79d translated
|
|
#[test]
|
|
fn attach_all_honors_recursive_add_folder() {
|
|
assert_eq!(
|
|
run("attachall", "Clothing", AttachSetup::RecursiveAddFolder),
|
|
recursive(true, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:e6bc1820d9335b07 6164ae5589e5a684637e9c85dd04e5e4c439c541be45b5ae2228e5c5edb2b79d translated
|
|
#[test]
|
|
fn attach_all_over_or_replace_honors_recursive_add_folder() {
|
|
assert_eq!(
|
|
run(
|
|
"attachalloverorreplace",
|
|
"Clothing",
|
|
AttachSetup::RecursiveAddFolder
|
|
),
|
|
recursive(true, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:fb63a8c8c9b75b99 6164ae5589e5a684637e9c85dd04e5e4c439c541be45b5ae2228e5c5edb2b79d translated
|
|
#[test]
|
|
fn attach_all_over_honors_recursive_add_folder() {
|
|
assert_eq!(
|
|
run("attachallover", "Clothing", AttachSetup::RecursiveAddFolder),
|
|
recursive(false, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_SourceFolderPrivate::case:eee2b1b757fc196e cdab3dc2313a5fec377f6fa0d49ac51b7ef58ede741d8c886f298b47efb508ae translated
|
|
#[test]
|
|
fn attach_all_allows_private_source() {
|
|
assert_eq!(
|
|
run("attachall", ".auto_attach", AttachSetup::PrivateSource),
|
|
recursive(true, true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_SourceFolderPrivate::case:e6bc1820d9335b07 cdab3dc2313a5fec377f6fa0d49ac51b7ef58ede741d8c886f298b47efb508ae translated
|
|
#[test]
|
|
fn attach_all_over_or_replace_allows_private_source() {
|
|
assert_eq!(
|
|
run(
|
|
"attachalloverorreplace",
|
|
".auto_attach",
|
|
AttachSetup::PrivateSource
|
|
),
|
|
recursive(true, true)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllCommandTests.cs::AttachAllCommandTests.AttachForce_Recursive_SourceFolderPrivate::case:fb63a8c8c9b75b99 cdab3dc2313a5fec377f6fa0d49ac51b7ef58ede741d8c886f298b47efb508ae translated
|
|
#[test]
|
|
fn attach_all_over_allows_private_source() {
|
|
assert_eq!(
|
|
run("attachallover", ".auto_attach", AttachSetup::PrivateSource),
|
|
recursive(false, false)
|
|
);
|
|
}
|
|
|
|
fn one_party(point: RlvAttachmentPoint, replace: bool) -> Vec<AttachmentCall> {
|
|
vec![call(PARTY, point, replace)]
|
|
}
|
|
fn this_by_id(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
]
|
|
}
|
|
fn this_add_folder() -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(HAPPY, RlvAttachmentPoint::Default, false),
|
|
call(RETRO, RlvAttachmentPoint::Default, false),
|
|
]
|
|
}
|
|
fn this_attachment_point(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
call(FANCY, RlvAttachmentPoint::Chin, replace),
|
|
]
|
|
}
|
|
fn this_wearable(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(HAPPY, RlvAttachmentPoint::Default, replace),
|
|
call(GLASSES, RlvAttachmentPoint::Default, replace),
|
|
]
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_Default::case:6882162efd904e15 3bd216683e650e5727244882dd61b16c58192e48438d8a8a831d60782d409fb2 translated
|
|
#[test]
|
|
fn attach_this_default() {
|
|
assert_eq!(
|
|
run_this("attachthis", None, AttachSetup::ThisDefault, true),
|
|
one_party(RlvAttachmentPoint::Spine, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_Default::case:45b5361aae1131d0 3bd216683e650e5727244882dd61b16c58192e48438d8a8a831d60782d409fb2 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_default() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
None,
|
|
AttachSetup::ThisDefault,
|
|
true
|
|
),
|
|
one_party(RlvAttachmentPoint::Spine, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_Default::case:f66e403049f440cf 3bd216683e650e5727244882dd61b16c58192e48438d8a8a831d60782d409fb2 translated
|
|
#[test]
|
|
fn attach_this_over_default() {
|
|
assert_eq!(
|
|
run_this("attachthisover", None, AttachSetup::ThisDefault, true),
|
|
one_party(RlvAttachmentPoint::Spine, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_ById::case:6882162efd904e15 3f6cc1241679d7746e58925c3c17aabf88a5c8694bbfda0fceb4b054d8b90392 translated
|
|
#[test]
|
|
fn attach_this_by_id() {
|
|
assert_eq!(
|
|
run_this("attachthis", Some(PRIM1), AttachSetup::ThisById, false),
|
|
this_by_id(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_ById::case:45b5361aae1131d0 3f6cc1241679d7746e58925c3c17aabf88a5c8694bbfda0fceb4b054d8b90392 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_by_id() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
Some(PRIM1),
|
|
AttachSetup::ThisById,
|
|
false
|
|
),
|
|
this_by_id(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_ById::case:f66e403049f440cf 3f6cc1241679d7746e58925c3c17aabf88a5c8694bbfda0fceb4b054d8b90392 translated
|
|
#[test]
|
|
fn attach_this_over_by_id() {
|
|
assert_eq!(
|
|
run_this("attachthisover", Some(PRIM1), AttachSetup::ThisById, false),
|
|
this_by_id(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesToAddInsteadOfReplace::case:a2681d046a6f6fef 67d84750193300b9445aa33d47d78f8fc5161b9456b7755d305568c695737a4b translated
|
|
#[test]
|
|
fn attach_this_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this("attachthis", None, AttachSetup::ThisAddFolder, true),
|
|
this_add_folder()
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesToAddInsteadOfReplace::case:34172d9d6ebbcf53 67d84750193300b9445aa33d47d78f8fc5161b9456b7755d305568c695737a4b translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
None,
|
|
AttachSetup::ThisAddFolder,
|
|
true
|
|
),
|
|
this_add_folder()
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesToAddInsteadOfReplace::case:30379630ffa50e68 67d84750193300b9445aa33d47d78f8fc5161b9456b7755d305568c695737a4b translated
|
|
#[test]
|
|
fn attach_this_over_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this("attachthisover", None, AttachSetup::ThisAddFolder, true),
|
|
this_add_folder()
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesRlvAttachmentPoint::case:6882162efd904e15 c45b9e08563acaf523fc8bddf5953e970bc773749d6f52b59f0806f104c24d27 translated
|
|
#[test]
|
|
fn attach_this_uses_folder_attachment_point() {
|
|
assert_eq!(
|
|
run_this("attachthis", None, AttachSetup::ThisFolderPoint, true),
|
|
one_party(RlvAttachmentPoint::Skull, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesRlvAttachmentPoint::case:45b5361aae1131d0 c45b9e08563acaf523fc8bddf5953e970bc773749d6f52b59f0806f104c24d27 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_uses_folder_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
None,
|
|
AttachSetup::ThisFolderPoint,
|
|
true
|
|
),
|
|
one_party(RlvAttachmentPoint::Skull, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FolderNameSpecifiesRlvAttachmentPoint::case:f66e403049f440cf c45b9e08563acaf523fc8bddf5953e970bc773749d6f52b59f0806f104c24d27 translated
|
|
#[test]
|
|
fn attach_this_over_uses_folder_attachment_point() {
|
|
assert_eq!(
|
|
run_this("attachthisover", None, AttachSetup::ThisFolderPoint, true),
|
|
one_party(RlvAttachmentPoint::Skull, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FromHiddenSubfolder::case:6882162efd904e15 059d647777a2d65d5a14f77aa6914449d1a9c0cbc876d3acccfa3a0de30988e8 translated
|
|
#[test]
|
|
fn attach_this_from_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this("attachthis", None, AttachSetup::ThisHidden, true),
|
|
one_party(RlvAttachmentPoint::Spine, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FromHiddenSubfolder::case:45b5361aae1131d0 059d647777a2d65d5a14f77aa6914449d1a9c0cbc876d3acccfa3a0de30988e8 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_from_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
None,
|
|
AttachSetup::ThisHidden,
|
|
true
|
|
),
|
|
one_party(RlvAttachmentPoint::Spine, true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_FromHiddenSubfolder::case:f66e403049f440cf 059d647777a2d65d5a14f77aa6914449d1a9c0cbc876d3acccfa3a0de30988e8 translated
|
|
#[test]
|
|
fn attach_this_over_from_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this("attachthisover", None, AttachSetup::ThisHidden, true),
|
|
one_party(RlvAttachmentPoint::Spine, false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_AttachPoint::case:6882162efd904e15 9e004ad47add2d97565c14c2d70bff08d1bea46d997140ad17ca5ffe04ee41a9 translated
|
|
#[test]
|
|
fn attach_this_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthis",
|
|
Some("spine"),
|
|
AttachSetup::ThisAttachmentPoint,
|
|
false
|
|
),
|
|
this_attachment_point(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_AttachPoint::case:45b5361aae1131d0 9e004ad47add2d97565c14c2d70bff08d1bea46d997140ad17ca5ffe04ee41a9 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
Some("spine"),
|
|
AttachSetup::ThisAttachmentPoint,
|
|
false
|
|
),
|
|
this_attachment_point(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_AttachPoint::case:f66e403049f440cf 9e004ad47add2d97565c14c2d70bff08d1bea46d997140ad17ca5ffe04ee41a9 translated
|
|
#[test]
|
|
fn attach_this_over_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisover",
|
|
Some("spine"),
|
|
AttachSetup::ThisAttachmentPoint,
|
|
false
|
|
),
|
|
this_attachment_point(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_RlvWearableType::case:6882162efd904e15 1c0adf85cffdece3b2576998e7c73921e8b842daf2e14ef1319e71c1f64797b3 translated
|
|
#[test]
|
|
fn attach_this_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthis",
|
|
Some("tattoo"),
|
|
AttachSetup::ThisWearable,
|
|
false
|
|
),
|
|
this_wearable(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_RlvWearableType::case:45b5361aae1131d0 1c0adf85cffdece3b2576998e7c73921e8b842daf2e14ef1319e71c1f64797b3 translated
|
|
#[test]
|
|
fn attach_this_over_or_replace_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisoverorreplace",
|
|
Some("tattoo"),
|
|
AttachSetup::ThisWearable,
|
|
false
|
|
),
|
|
this_wearable(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachThisCommandTests.cs::AttachThisCommandTests.AttachThis_RlvWearableType::case:f66e403049f440cf 1c0adf85cffdece3b2576998e7c73921e8b842daf2e14ef1319e71c1f64797b3 translated
|
|
#[test]
|
|
fn attach_this_over_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachthisover",
|
|
Some("tattoo"),
|
|
AttachSetup::ThisWearable,
|
|
false
|
|
),
|
|
this_wearable(false)
|
|
);
|
|
}
|
|
|
|
fn all_this(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
call(PARTY, RlvAttachmentPoint::Spine, replace),
|
|
call(FANCY, RlvAttachmentPoint::Chin, replace),
|
|
]
|
|
}
|
|
fn all_this_hidden(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
]
|
|
}
|
|
fn all_this_add(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
call(PARTY, RlvAttachmentPoint::Spine, false),
|
|
call(FANCY, RlvAttachmentPoint::Chin, false),
|
|
]
|
|
}
|
|
fn all_this_point(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(RETRO, RlvAttachmentPoint::Default, replace),
|
|
call(GLASSES, RlvAttachmentPoint::Default, replace),
|
|
call(PARTY, RlvAttachmentPoint::Spine, replace),
|
|
call(FANCY, RlvAttachmentPoint::Chin, replace),
|
|
]
|
|
}
|
|
fn all_this_wearable(replace: bool) -> Vec<AttachmentCall> {
|
|
vec![
|
|
call(BUSINESS, RlvAttachmentPoint::Pelvis, replace),
|
|
call(HAPPY, RlvAttachmentPoint::Default, replace),
|
|
call(PARTY, RlvAttachmentPoint::Spine, replace),
|
|
call(FANCY, RlvAttachmentPoint::Chin, replace),
|
|
]
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive::case:bc5a9cb6a299a551 be84d92abe19975bbf7a680f077d36956f33873a2b65bfebff8eddf6458b77c9 translated
|
|
#[test]
|
|
fn attach_all_this_recursive() {
|
|
assert_eq!(
|
|
run_this("attachallthis", None, AttachSetup::AllThis, true),
|
|
all_this(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive::case:0f04a34ae77465d3 be84d92abe19975bbf7a680f077d36956f33873a2b65bfebff8eddf6458b77c9 translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_recursive() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
None,
|
|
AttachSetup::AllThis,
|
|
true
|
|
),
|
|
all_this(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive::case:1560d5268a46ddf1 be84d92abe19975bbf7a680f077d36956f33873a2b65bfebff8eddf6458b77c9 translated
|
|
#[test]
|
|
fn attach_all_this_over_recursive() {
|
|
assert_eq!(
|
|
run_this("attachallthisover", None, AttachSetup::AllThis, true),
|
|
all_this(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_ById::case:bc5a9cb6a299a551 dfc11c1f68841153e34d37f98884c041366bd89d754b0f3421a166f09436daa7 translated
|
|
#[test]
|
|
fn attach_all_this_recursive_by_id() {
|
|
assert_eq!(
|
|
run_this("attachallthis", Some(PRIM1), AttachSetup::AllThis, false),
|
|
all_this(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_ById::case:0f04a34ae77465d3 dfc11c1f68841153e34d37f98884c041366bd89d754b0f3421a166f09436daa7 translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_recursive_by_id() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
Some(PRIM1),
|
|
AttachSetup::AllThis,
|
|
false
|
|
),
|
|
all_this(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_ById::case:1560d5268a46ddf1 dfc11c1f68841153e34d37f98884c041366bd89d754b0f3421a166f09436daa7 translated
|
|
#[test]
|
|
fn attach_all_this_over_recursive_by_id() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisover",
|
|
Some(PRIM1),
|
|
AttachSetup::AllThis,
|
|
false
|
|
),
|
|
all_this(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_WithHiddenSubfolder::case:bc5a9cb6a299a551 cfdb334a613f22babdc58f2fb96a884ed7e7a2fd339ec396a71f4decc02a3747 translated
|
|
#[test]
|
|
fn attach_all_this_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this("attachallthis", None, AttachSetup::AllThisHidden, true),
|
|
all_this_hidden(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_WithHiddenSubfolder::case:0f04a34ae77465d3 cfdb334a613f22babdc58f2fb96a884ed7e7a2fd339ec396a71f4decc02a3747 translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
None,
|
|
AttachSetup::AllThisHidden,
|
|
true
|
|
),
|
|
all_this_hidden(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_WithHiddenSubfolder::case:1560d5268a46ddf1 cfdb334a613f22babdc58f2fb96a884ed7e7a2fd339ec396a71f4decc02a3747 translated
|
|
#[test]
|
|
fn attach_all_this_over_skips_hidden_subfolder() {
|
|
assert_eq!(
|
|
run_this("attachallthisover", None, AttachSetup::AllThisHidden, true),
|
|
all_this_hidden(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:bc5a9cb6a299a551 780e7212749cb332abbf1a1cef33ed8938584b817476d39424b4628d34c3f4ea translated
|
|
#[test]
|
|
fn attach_all_this_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this("attachallthis", None, AttachSetup::AllThisAddFolder, true),
|
|
all_this_add(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:0f04a34ae77465d3 780e7212749cb332abbf1a1cef33ed8938584b817476d39424b4628d34c3f4ea translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
None,
|
|
AttachSetup::AllThisAddFolder,
|
|
true
|
|
),
|
|
all_this_add(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_Recursive_FolderNameSpecifiesToAddInsteadOfReplace::case:1560d5268a46ddf1 780e7212749cb332abbf1a1cef33ed8938584b817476d39424b4628d34c3f4ea translated
|
|
#[test]
|
|
fn attach_all_this_over_honors_add_folder() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisover",
|
|
None,
|
|
AttachSetup::AllThisAddFolder,
|
|
true
|
|
),
|
|
all_this_add(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_AttachPoint::case:bc5a9cb6a299a551 4115d8f4e18acc9992e84f30962536c4cd15db2e4c8c54aa840f5ee397ba8613 translated
|
|
#[test]
|
|
fn attach_all_this_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthis",
|
|
Some("skull"),
|
|
AttachSetup::AllThisAttachmentPoint,
|
|
false
|
|
),
|
|
all_this_point(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_AttachPoint::case:0f04a34ae77465d3 4115d8f4e18acc9992e84f30962536c4cd15db2e4c8c54aa840f5ee397ba8613 translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
Some("skull"),
|
|
AttachSetup::AllThisAttachmentPoint,
|
|
false
|
|
),
|
|
all_this_point(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_AttachPoint::case:1560d5268a46ddf1 4115d8f4e18acc9992e84f30962536c4cd15db2e4c8c54aa840f5ee397ba8613 translated
|
|
#[test]
|
|
fn attach_all_this_over_by_attachment_point() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisover",
|
|
Some("skull"),
|
|
AttachSetup::AllThisAttachmentPoint,
|
|
false
|
|
),
|
|
all_this_point(false)
|
|
);
|
|
}
|
|
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_RlvWearableType::case:bc5a9cb6a299a551 91d47986c684dfb289df7f867f847d270324cbc6754a24aaa009b3a96226661d translated
|
|
#[test]
|
|
fn attach_all_this_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthis",
|
|
Some("tattoo"),
|
|
AttachSetup::AllThisWearable,
|
|
false
|
|
),
|
|
all_this_wearable(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_RlvWearableType::case:0f04a34ae77465d3 91d47986c684dfb289df7f867f847d270324cbc6754a24aaa009b3a96226661d translated
|
|
#[test]
|
|
fn attach_all_this_over_or_replace_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisoverorreplace",
|
|
Some("tattoo"),
|
|
AttachSetup::AllThisWearable,
|
|
false
|
|
),
|
|
all_this_wearable(true)
|
|
);
|
|
}
|
|
// parity-case: LibreMetaverse.Tests/RLV/Commands/AttachAllThisCommandTests.cs::AttachAllThisCommandTests.AttachAllThisForce_RlvWearableType::case:1560d5268a46ddf1 91d47986c684dfb289df7f867f847d270324cbc6754a24aaa009b3a96226661d translated
|
|
#[test]
|
|
fn attach_all_this_over_by_wearable() {
|
|
assert_eq!(
|
|
run_this(
|
|
"attachallthisover",
|
|
Some("tattoo"),
|
|
AttachSetup::AllThisWearable,
|
|
false
|
|
),
|
|
all_this_wearable(false)
|
|
);
|
|
}
|