Function union_compatible_enum_xlang_format

rust/tests/tests/test_enum.rs:182–245

()

/// which should be compatible with Java's Union: index + xwriteRef(value)
#[test]
fn union_compatible_enum_xlang_format() {
    use fory_core::serializer::{ForyDefault, Serializer};
    use fory_core::type_id::TypeId;

    // Define a Union-compatible enum (each variant has exactly one field)
    #[allow(dead_code)]
    #[derive(ForyUnion, Debug, PartialEq, Clone)]
    enum StringOrLong {
        #[fory(unknown)]
        Unknown(fory_core::UnknownCase),
        #[fory(id = 0, default)]
        Text(String),
        #[fory(id = 1)]
        Number(i64),
    }

    #[allow(dead_code)]
    #[derive(ForyUnion, Debug, PartialEq, Clone)]
    enum ForwardStringOrLong {
        #[fory(unknown)]
        Unknown(fory_core::UnknownCase),
        #[fory(id = 0, default)]
        Text(String),
        #[fory(id = 1)]
        Number(i64),
    }

    // Verify it's recognized as UNION TypeId
    assert_eq!(
        StringOrLong::fory_static_type_id(),
        TypeId::UNION,
        "Union-compatible enum should have UNION TypeId"
    );
    assert_eq!(
        ForwardStringOrLong::fory_default(),
        ForwardStringOrLong::Text(String::new())
    );
    // Struct containing the Union-compatible enum
    #[derive(ForyStruct, Debug, PartialEq)]
    struct StructWithUnion {
        union_field: StringOrLong,
    }

    // Test xlang mode serialization
    let mut fory = Fory::builder().xlang(true).compatible(false).build();
    fory.register::<StringOrLong>(300).unwrap();
    fory.register::<StructWithUnion>(301).unwrap();

    // Test with String variant (index 0)
    let obj1 = StructWithUnion {
        union_field: StringOrLong::Text("hello".to_string()),
    };
    let bin1 = fory.serialize(&obj1).unwrap();
    let result1: StructWithUnion = fory.deserialize(&bin1).unwrap();
    assert_eq!(obj1, result1);

    // Test with Long variant (index 1)
    let obj2 = StructWithUnion {