//! 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)
    );
}
