facet_generate 0.16.0

//! Snapshot tests for the Swift emitter — **Bincode encoding**.
//!
//! Mirrors the structure of [`tests`](super::tests) but uses `Encoding::Bincode`
//! so that every generated type includes `Hashable` conformance, hand-written
//! `serialize`/`deserialize` methods, plus `bincodeSerialize`/`bincodeDeserialize`
//! convenience wrappers.
//!
//! These tests verify the byte-level serialization code that the emitter
//! produces: field ordering, nested `serialize`/`deserialize` calls for
//! user-defined types, collection helpers (`serializeArray`, `deserializeMap`,
//! etc.), option encoding (`serializeOption`/`deserializeOption`), and the
//! `Serializer`/`Deserializer` protocol API surface.

#![allow(clippy::too_many_lines)]

use std::{
    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
    rc::Rc,
    sync::Arc,
};

use crate as fg;
use facet::Facet;

use super::*;
use crate::{emit, generation::Encoding};

#[test]
fn unit_struct_1() {
    /// line 1
    #[derive(Facet)]
    /// line 2
    struct UnitStruct;

    let actual = emit!(UnitStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct UnitStruct: Hashable {

        public init() {
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> UnitStruct {
            try deserializer.increase_container_depth()
            try deserializer.decrease_container_depth()
            return UnitStruct()
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> UnitStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn unit_struct_2() {
    /// line 1
    #[derive(Facet)]
    /// line 2
    struct UnitStruct {}

    let actual = emit!(UnitStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct UnitStruct: Hashable {

        public init() {
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> UnitStruct {
            try deserializer.increase_container_depth()
            try deserializer.decrease_container_depth()
            return UnitStruct()
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> UnitStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn newtype_struct() {
    /// line 1
    #[derive(Facet)]
    /// line 2
    struct NewType(String);

    let actual = emit!(NewType as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct NewType: Hashable {
        @Indirect public var value: String

        public init(value: String) {
            self.value = value
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.value)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> NewType {
            try deserializer.increase_container_depth()
            let value = try deserializer.deserialize_str()
            try deserializer.decrease_container_depth()
            return NewType(value: value)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> NewType {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn tuple_struct() {
    /// line 1
    #[derive(Facet)]
    /// line 2
    struct TupleStruct(String, i32);

    let actual = emit!(TupleStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct TupleStruct: Hashable {
        @Indirect public var field0: String
        @Indirect public var field1: Int32

        public init(field0: String, field1: Int32) {
            self.field0 = field0
            self.field1 = field1
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.field0)
            try serializer.serialize_i32(value: self.field1)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> TupleStruct {
            try deserializer.increase_container_depth()
            let field0 = try deserializer.deserialize_str()
            let field1 = try deserializer.deserialize_i32()
            try deserializer.decrease_container_depth()
            return TupleStruct(field0: field0, field1: field1)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> TupleStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_fields_of_primitive_types() {
    /// line 1
    #[derive(Facet)]
    /// line 2
    struct StructWithFields {
        /// unit type
        unit: (),
        /// boolean
        bool: bool,
        i8: i8,
        i16: i16,
        i32: i32,
        i64: i64,
        i128: i128,
        u8: u8,
        u16: u16,
        u32: u32,
        u64: u64,
        u128: u128,
        f32: f32,
        f64: f64,
        char: char,
        string: String,
    }

    let actual = emit!(StructWithFields as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct StructWithFields: Hashable {
        @Indirect public var unit: Unit
        @Indirect public var bool: Bool
        @Indirect public var i8: Int8
        @Indirect public var i16: Int16
        @Indirect public var i32: Int32
        @Indirect public var i64: Int64
        @Indirect public var i128: Int128
        @Indirect public var u8: UInt8
        @Indirect public var u16: UInt16
        @Indirect public var u32: UInt32
        @Indirect public var u64: UInt64
        @Indirect public var u128: UInt128
        @Indirect public var f32: Float
        @Indirect public var f64: Double
        @Indirect public var char: Character
        @Indirect public var string: String

        public init(unit: Unit, bool: Bool, i8: Int8, i16: Int16, i32: Int32, i64: Int64, i128: Int128, u8: UInt8, u16: UInt16, u32: UInt32, u64: UInt64, u128: UInt128, f32: Float, f64: Double, char: Character, string: String) {
            self.unit = unit
            self.bool = bool
            self.i8 = i8
            self.i16 = i16
            self.i32 = i32
            self.i64 = i64
            self.i128 = i128
            self.u8 = u8
            self.u16 = u16
            self.u32 = u32
            self.u64 = u64
            self.u128 = u128
            self.f32 = f32
            self.f64 = f64
            self.char = char
            self.string = string
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_unit(value: self.unit)
            try serializer.serialize_bool(value: self.bool)
            try serializer.serialize_i8(value: self.i8)
            try serializer.serialize_i16(value: self.i16)
            try serializer.serialize_i32(value: self.i32)
            try serializer.serialize_i64(value: self.i64)
            try serializer.serialize_i128(value: self.i128)
            try serializer.serialize_u8(value: self.u8)
            try serializer.serialize_u16(value: self.u16)
            try serializer.serialize_u32(value: self.u32)
            try serializer.serialize_u64(value: self.u64)
            try serializer.serialize_u128(value: self.u128)
            try serializer.serialize_f32(value: self.f32)
            try serializer.serialize_f64(value: self.f64)
            try serializer.serialize_char(value: self.char)
            try serializer.serialize_str(value: self.string)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> StructWithFields {
            try deserializer.increase_container_depth()
            let unit = try deserializer.deserialize_unit()
            let bool = try deserializer.deserialize_bool()
            let i8 = try deserializer.deserialize_i8()
            let i16 = try deserializer.deserialize_i16()
            let i32 = try deserializer.deserialize_i32()
            let i64 = try deserializer.deserialize_i64()
            let i128 = try deserializer.deserialize_i128()
            let u8 = try deserializer.deserialize_u8()
            let u16 = try deserializer.deserialize_u16()
            let u32 = try deserializer.deserialize_u32()
            let u64 = try deserializer.deserialize_u64()
            let u128 = try deserializer.deserialize_u128()
            let f32 = try deserializer.deserialize_f32()
            let f64 = try deserializer.deserialize_f64()
            let char = try deserializer.deserialize_char()
            let string = try deserializer.deserialize_str()
            try deserializer.decrease_container_depth()
            return StructWithFields(unit: unit, bool: bool, i8: i8, i16: i16, i32: i32, i64: i64, i128: i128, u8: u8, u16: u16, u32: u32, u64: u64, u128: u128, f32: f32, f64: f64, char: char, string: string)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> StructWithFields {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_fields_of_user_types() {
    #[derive(Facet)]
    struct Inner1 {
        field1: String,
    }

    #[derive(Facet)]
    struct Inner2(String);

    #[derive(Facet)]
    struct Inner3(String, i32);

    #[derive(Facet)]
    struct Outer {
        one: Inner1,
        two: Inner2,
        three: Inner3,
    }

    let actual = emit!(Outer as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct Inner1: Hashable {
        @Indirect public var field1: String

        public init(field1: String) {
            self.field1 = field1
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.field1)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Inner1 {
            try deserializer.increase_container_depth()
            let field1 = try deserializer.deserialize_str()
            try deserializer.decrease_container_depth()
            return Inner1(field1: field1)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Inner1 {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }

    public struct Inner2: Hashable {
        @Indirect public var value: String

        public init(value: String) {
            self.value = value
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.value)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Inner2 {
            try deserializer.increase_container_depth()
            let value = try deserializer.deserialize_str()
            try deserializer.decrease_container_depth()
            return Inner2(value: value)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Inner2 {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }

    public struct Inner3: Hashable {
        @Indirect public var field0: String
        @Indirect public var field1: Int32

        public init(field0: String, field1: Int32) {
            self.field0 = field0
            self.field1 = field1
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.field0)
            try serializer.serialize_i32(value: self.field1)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Inner3 {
            try deserializer.increase_container_depth()
            let field0 = try deserializer.deserialize_str()
            let field1 = try deserializer.deserialize_i32()
            try deserializer.decrease_container_depth()
            return Inner3(field0: field0, field1: field1)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Inner3 {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }

    public struct Outer: Hashable {
        @Indirect public var one: Inner1
        @Indirect public var two: Inner2
        @Indirect public var three: Inner3

        public init(one: Inner1, two: Inner2, three: Inner3) {
            self.one = one
            self.two = two
            self.three = three
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try self.one.serialize(serializer: serializer)
            try self.two.serialize(serializer: serializer)
            try self.three.serialize(serializer: serializer)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Outer {
            try deserializer.increase_container_depth()
            let one = try Inner1.deserialize(deserializer: deserializer)
            let two = try Inner2.deserialize(deserializer: deserializer)
            let three = try Inner3.deserialize(deserializer: deserializer)
            try deserializer.decrease_container_depth()
            return Outer(one: one, two: two, three: three)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Outer {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_field_that_is_a_2_tuple() {
    #[derive(Facet)]
    struct MyStruct {
        one: (String, i32),
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var one: Tuple2<String, Int32>

        public init(one: Tuple2<String, Int32>) {
            self.one = one
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.one.field0)
            try serializer.serialize_i32(value: self.one.field1)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let oneField0 = try deserializer.deserialize_str()
            let oneField1 = try deserializer.deserialize_i32()
            let one = Tuple2(oneField0, oneField1)
            try deserializer.decrease_container_depth()
            return MyStruct(one: one)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_field_that_is_a_3_tuple() {
    #[derive(Facet)]
    struct MyStruct {
        one: (String, i32, u16),
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var one: Tuple3<String, Int32, UInt16>

        public init(one: Tuple3<String, Int32, UInt16>) {
            self.one = one
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.one.field0)
            try serializer.serialize_i32(value: self.one.field1)
            try serializer.serialize_u16(value: self.one.field2)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let oneField0 = try deserializer.deserialize_str()
            let oneField1 = try deserializer.deserialize_i32()
            let oneField2 = try deserializer.deserialize_u16()
            let one = Tuple3(oneField0, oneField1, oneField2)
            try deserializer.decrease_container_depth()
            return MyStruct(one: one)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_field_that_is_a_4_tuple() {
    #[derive(Facet)]
    struct MyStruct {
        one: (String, i32, u16, f32),
    }

    // TODO: The NTuple4 struct should be emitted in the preamble if required, e.g.
    // data class NTuple4<T1, T2, T3, T4>(val t1: T1, val t2: T2, val t3: T3, val t4: T4)

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var one: Tuple4<String, Int32, UInt16, Float>

        public init(one: Tuple4<String, Int32, UInt16, Float>) {
            self.one = one
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.one.field0)
            try serializer.serialize_i32(value: self.one.field1)
            try serializer.serialize_u16(value: self.one.field2)
            try serializer.serialize_f32(value: self.one.field3)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let oneField0 = try deserializer.deserialize_str()
            let oneField1 = try deserializer.deserialize_i32()
            let oneField2 = try deserializer.deserialize_u16()
            let oneField3 = try deserializer.deserialize_f32()
            let one = Tuple4(oneField0, oneField1, oneField2, oneField3)
            try deserializer.decrease_container_depth()
            return MyStruct(one: one)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_unit_variants() {
    /// line one
    #[derive(Facet)]
    #[repr(C)]
    /// line two
    #[allow(unused)]
    enum EnumWithUnitVariants {
        /// variant one
        Variant1,
        /// variant two
        Variant2,
        /// variant three
        Variant3,
    }

    let actual = emit!(EnumWithUnitVariants as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum EnumWithUnitVariants: Hashable {
        case variant1
        case variant2
        case variant3

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1:
                try serializer.serialize_variant_index(value: 0)
            case .variant2:
                try serializer.serialize_variant_index(value: 1)
            case .variant3:
                try serializer.serialize_variant_index(value: 2)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> EnumWithUnitVariants {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                try deserializer.decrease_container_depth()
                return .variant1
            case 1:
                try deserializer.decrease_container_depth()
                return .variant2
            case 2:
                try deserializer.decrease_container_depth()
                return .variant3
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for EnumWithUnitVariants: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> EnumWithUnitVariants {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_unit_struct_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Variant1 {},
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case variant1

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1:
                try serializer.serialize_variant_index(value: 0)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                try deserializer.decrease_container_depth()
                return .variant1
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_1_tuple_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Variant1(String),
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case variant1(String)

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1(let x):
                try serializer.serialize_variant_index(value: 0)
                try serializer.serialize_str(value: x)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                let x = try deserializer.deserialize_str()
                try deserializer.decrease_container_depth()
                return .variant1(x)
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_newtype_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Variant1(String),
        Variant2(i32),
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case variant1(String)
        case variant2(Int32)

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1(let x):
                try serializer.serialize_variant_index(value: 0)
                try serializer.serialize_str(value: x)
            case .variant2(let x):
                try serializer.serialize_variant_index(value: 1)
                try serializer.serialize_i32(value: x)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                let x = try deserializer.deserialize_str()
                try deserializer.decrease_container_depth()
                return .variant1(x)
            case 1:
                let x = try deserializer.deserialize_i32()
                try deserializer.decrease_container_depth()
                return .variant2(x)
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_tuple_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Variant1(String, i32),
        Variant2(bool, f64, u8),
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case variant1(String, Int32)
        case variant2(Bool, Double, UInt8)

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1(let x0, let x1):
                try serializer.serialize_variant_index(value: 0)
                try serializer.serialize_str(value: x0)
                try serializer.serialize_i32(value: x1)
            case .variant2(let x0, let x1, let x2):
                try serializer.serialize_variant_index(value: 1)
                try serializer.serialize_bool(value: x0)
                try serializer.serialize_f64(value: x1)
                try serializer.serialize_u8(value: x2)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                let x0 = try deserializer.deserialize_str()
                let x1 = try deserializer.deserialize_i32()
                try deserializer.decrease_container_depth()
                return .variant1(x0, x1)
            case 1:
                let x0 = try deserializer.deserialize_bool()
                let x1 = try deserializer.deserialize_f64()
                let x2 = try deserializer.deserialize_u8()
                try deserializer.decrease_container_depth()
                return .variant2(x0, x1, x2)
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_struct_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Variant1 { field1: String, field2: i32 },
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case variant1(field1: String, field2: Int32)

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .variant1(let field1, let field2):
                try serializer.serialize_variant_index(value: 0)
                try serializer.serialize_str(value: field1)
                try serializer.serialize_i32(value: field2)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                let field1 = try deserializer.deserialize_str()
                let field2 = try deserializer.deserialize_i32()
                try deserializer.decrease_container_depth()
                return .variant1(field1: field1, field2: field2)
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn enum_with_mixed_variants() {
    #[derive(Facet)]
    #[repr(C)]
    #[allow(unused)]
    enum MyEnum {
        Unit,
        NewType(String),
        Tuple(String, i32),
        Struct { field: bool },
    }

    let actual = emit!(MyEnum as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    indirect public enum MyEnum: Hashable {
        case unit
        case newType(String)
        case tuple(String, Int32)
        case struct(field: Bool)

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            switch self {
            case .unit:
                try serializer.serialize_variant_index(value: 0)
            case .newType(let x):
                try serializer.serialize_variant_index(value: 1)
                try serializer.serialize_str(value: x)
            case .tuple(let x0, let x1):
                try serializer.serialize_variant_index(value: 2)
                try serializer.serialize_str(value: x0)
                try serializer.serialize_i32(value: x1)
            case .struct(let field):
                try serializer.serialize_variant_index(value: 3)
                try serializer.serialize_bool(value: field)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyEnum {
            let index = try deserializer.deserialize_variant_index()
            try deserializer.increase_container_depth()
            switch index {
            case 0:
                try deserializer.decrease_container_depth()
                return .unit
            case 1:
                let x = try deserializer.deserialize_str()
                try deserializer.decrease_container_depth()
                return .newType(x)
            case 2:
                let x0 = try deserializer.deserialize_str()
                let x1 = try deserializer.deserialize_i32()
                try deserializer.decrease_container_depth()
                return .tuple(x0, x1)
            case 3:
                let field = try deserializer.deserialize_bool()
                try deserializer.decrease_container_depth()
                return .struct(field: field)
            default: throw DeserializationError.invalidInput(issue: "Unknown variant index for MyEnum: \(index)")
            }
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyEnum {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_vec_field() {
    #[derive(Facet)]
    struct MyStruct {
        items: Vec<String>,
        numbers: Vec<i32>,
        nested_items: Vec<Vec<String>>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var items: [String]
        @Indirect public var numbers: [Int32]
        @Indirect public var nestedItems: [[String]]

        public init(items: [String], numbers: [Int32], nestedItems: [[String]]) {
            self.items = items
            self.numbers = numbers
            self.nestedItems = nestedItems
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeArray(value: self.items, serializer: serializer) { item, serializer in
                try serializer.serialize_str(value: item)
            }
            try serializeArray(value: self.numbers, serializer: serializer) { item, serializer in
                try serializer.serialize_i32(value: item)
            }
            try serializeArray(value: self.nestedItems, serializer: serializer) { item, serializer in
                try serializeArray(value: item, serializer: serializer) { item, serializer in
                    try serializer.serialize_str(value: item)
                }
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let items = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let numbers = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_i32()
            }
            let nestedItems = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializeArray(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_str()
                }
            }
            try deserializer.decrease_container_depth()
            return MyStruct(items: items, numbers: numbers, nestedItems: nestedItems)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_option_field() {
    #[derive(Facet)]
    #[allow(clippy::struct_field_names)]
    struct MyStruct {
        optional_string: Option<String>,
        optional_number: Option<i32>,
        optional_bool: Option<bool>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var optionalString: String?
        @Indirect public var optionalNumber: Int32?
        @Indirect public var optionalBool: Bool?

        public init(optionalString: String?, optionalNumber: Int32?, optionalBool: Bool?) {
            self.optionalString = optionalString
            self.optionalNumber = optionalNumber
            self.optionalBool = optionalBool
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeOption(value: self.optionalString, serializer: serializer) { value, serializer in
                try serializer.serialize_str(value: value)
            }
            try serializeOption(value: self.optionalNumber, serializer: serializer) { value, serializer in
                try serializer.serialize_i32(value: value)
            }
            try serializeOption(value: self.optionalBool, serializer: serializer) { value, serializer in
                try serializer.serialize_bool(value: value)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let optionalString = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let optionalNumber = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_i32()
            }
            let optionalBool = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_bool()
            }
            try deserializer.decrease_container_depth()
            return MyStruct(optionalString: optionalString, optionalNumber: optionalNumber, optionalBool: optionalBool)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_hashmap_field() {
    #[derive(Facet)]
    struct MyStruct {
        string_to_int: HashMap<String, i32>,
        int_to_bool: HashMap<i32, bool>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var stringToInt: [String: Int32]
        @Indirect public var intToBool: [Int32: Bool]

        public init(stringToInt: [String: Int32], intToBool: [Int32: Bool]) {
            self.stringToInt = stringToInt
            self.intToBool = intToBool
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeMap(value: self.stringToInt, serializer: serializer) { key, value, serializer in
                try serializer.serialize_str(value: key)
                try serializer.serialize_i32(value: value)
            }
            try serializeMap(value: self.intToBool, serializer: serializer) { key, value, serializer in
                try serializer.serialize_i32(value: key)
                try serializer.serialize_bool(value: value)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let stringToInt = try deserializeMap(deserializer: deserializer) { deserializer in
                let key = try deserializer.deserialize_str()
                let value = try deserializer.deserialize_i32()
                return (key, value)
            }
            let intToBool = try deserializeMap(deserializer: deserializer) { deserializer in
                let key = try deserializer.deserialize_i32()
                let value = try deserializer.deserialize_bool()
                return (key, value)
            }
            try deserializer.decrease_container_depth()
            return MyStruct(stringToInt: stringToInt, intToBool: intToBool)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_nested_generics() {
    #[derive(Facet)]
    struct MyStruct {
        optional_list: Option<Vec<String>>,
        list_of_optionals: Vec<Option<i32>>,
        map_to_list: HashMap<String, Vec<bool>>,
        optional_map: Option<HashMap<String, i32>>,
        complex: Vec<Option<HashMap<String, Vec<bool>>>>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var optionalList: [String]?
        @Indirect public var listOfOptionals: [Int32?]
        @Indirect public var mapToList: [String: [Bool]]
        @Indirect public var optionalMap: [String: Int32]?
        @Indirect public var complex: [[String: [Bool]]?]

        public init(optionalList: [String]?, listOfOptionals: [Int32?], mapToList: [String: [Bool]], optionalMap: [String: Int32]?, complex: [[String: [Bool]]?]) {
            self.optionalList = optionalList
            self.listOfOptionals = listOfOptionals
            self.mapToList = mapToList
            self.optionalMap = optionalMap
            self.complex = complex
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeOption(value: self.optionalList, serializer: serializer) { value, serializer in
                try serializeArray(value: value, serializer: serializer) { item, serializer in
                    try serializer.serialize_str(value: item)
                }
            }
            try serializeArray(value: self.listOfOptionals, serializer: serializer) { item, serializer in
                try serializeOption(value: item, serializer: serializer) { value, serializer in
                    try serializer.serialize_i32(value: value)
                }
            }
            try serializeMap(value: self.mapToList, serializer: serializer) { key, value, serializer in
                try serializer.serialize_str(value: key)
                try serializeArray(value: value, serializer: serializer) { item, serializer in
                    try serializer.serialize_bool(value: item)
                }
            }
            try serializeOption(value: self.optionalMap, serializer: serializer) { value, serializer in
                try serializeMap(value: value, serializer: serializer) { key, value, serializer in
                    try serializer.serialize_str(value: key)
                    try serializer.serialize_i32(value: value)
                }
            }
            try serializeArray(value: self.complex, serializer: serializer) { item, serializer in
                try serializeOption(value: item, serializer: serializer) { value, serializer in
                    try serializeMap(value: value, serializer: serializer) { key, value, serializer in
                        try serializer.serialize_str(value: key)
                        try serializeArray(value: value, serializer: serializer) { item, serializer in
                            try serializer.serialize_bool(value: item)
                        }
                    }
                }
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let optionalList = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializeArray(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_str()
                }
            }
            let listOfOptionals = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializeOption(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_i32()
                }
            }
            let mapToList = try deserializeMap(deserializer: deserializer) { deserializer in
                let key = try deserializer.deserialize_str()
                let value = try deserializeArray(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_bool()
                }
                return (key, value)
            }
            let optionalMap = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializeMap(deserializer: deserializer) { deserializer in
                    let key = try deserializer.deserialize_str()
                    let value = try deserializer.deserialize_i32()
                    return (key, value)
                }
            }
            let complex = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializeOption(deserializer: deserializer) { deserializer in
                    try deserializeMap(deserializer: deserializer) { deserializer in
                        let key = try deserializer.deserialize_str()
                        let value = try deserializeArray(deserializer: deserializer) { deserializer in
                            try deserializer.deserialize_bool()
                        }
                        return (key, value)
                    }
                }
            }
            try deserializer.decrease_container_depth()
            return MyStruct(optionalList: optionalList, listOfOptionals: listOfOptionals, mapToList: mapToList, optionalMap: optionalMap, complex: complex)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_array_field() {
    #[derive(Facet)]
    #[allow(clippy::struct_field_names)]
    struct MyStruct {
        fixed_array: [i32; 5],
        byte_array: [u8; 32],
        string_array: [String; 3],
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var fixedArray: [Int32]
        @Indirect public var byteArray: [UInt8]
        @Indirect public var stringArray: [String]

        public init(fixedArray: [Int32], byteArray: [UInt8], stringArray: [String]) {
            self.fixedArray = fixedArray
            self.byteArray = byteArray
            self.stringArray = stringArray
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeTupleArray(value: self.fixedArray, serializer: serializer) { item, serializer in
                try serializer.serialize_i32(value: item)
            }
            try serializeTupleArray(value: self.byteArray, serializer: serializer) { item, serializer in
                try serializer.serialize_u8(value: item)
            }
            try serializeTupleArray(value: self.stringArray, serializer: serializer) { item, serializer in
                try serializer.serialize_str(value: item)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let fixedArray = try deserializeTupleArray(deserializer: deserializer, size: 5) { deserializer in
                try deserializer.deserialize_i32()
            }
            let byteArray = try deserializeTupleArray(deserializer: deserializer, size: 32) { deserializer in
                try deserializer.deserialize_u8()
            }
            let stringArray = try deserializeTupleArray(deserializer: deserializer, size: 3) { deserializer in
                try deserializer.deserialize_str()
            }
            try deserializer.decrease_container_depth()
            return MyStruct(fixedArray: fixedArray, byteArray: byteArray, stringArray: stringArray)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_btreemap_field() {
    #[derive(Facet)]
    struct MyStruct {
        string_to_int: BTreeMap<String, i32>,
        int_to_bool: BTreeMap<i32, bool>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var stringToInt: [String: Int32]
        @Indirect public var intToBool: [Int32: Bool]

        public init(stringToInt: [String: Int32], intToBool: [Int32: Bool]) {
            self.stringToInt = stringToInt
            self.intToBool = intToBool
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeMap(value: self.stringToInt, serializer: serializer) { key, value, serializer in
                try serializer.serialize_str(value: key)
                try serializer.serialize_i32(value: value)
            }
            try serializeMap(value: self.intToBool, serializer: serializer) { key, value, serializer in
                try serializer.serialize_i32(value: key)
                try serializer.serialize_bool(value: value)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let stringToInt = try deserializeMap(deserializer: deserializer) { deserializer in
                let key = try deserializer.deserialize_str()
                let value = try deserializer.deserialize_i32()
                return (key, value)
            }
            let intToBool = try deserializeMap(deserializer: deserializer) { deserializer in
                let key = try deserializer.deserialize_i32()
                let value = try deserializer.deserialize_bool()
                return (key, value)
            }
            try deserializer.decrease_container_depth()
            return MyStruct(stringToInt: stringToInt, intToBool: intToBool)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_hashset_field() {
    // NOTE: HashSet<T> now maps to Set<T> in Kotlin with the new Format::Set variant.
    // This preserves the uniqueness constraint and provides better type safety.
    #[derive(Facet)]
    struct MyStruct {
        string_set: HashSet<String>,
        int_set: HashSet<i32>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var stringSet: Set<String>
        @Indirect public var intSet: Set<Int32>

        public init(stringSet: Set<String>, intSet: Set<Int32>) {
            self.stringSet = stringSet
            self.intSet = intSet
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeSet(value: self.stringSet, serializer: serializer) { item, serializer in
                try serializer.serialize_str(value: item)
            }
            try serializeSet(value: self.intSet, serializer: serializer) { item, serializer in
                try serializer.serialize_i32(value: item)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let stringSet = try deserializeSet(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let intSet = try deserializeSet(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_i32()
            }
            try deserializer.decrease_container_depth()
            return MyStruct(stringSet: stringSet, intSet: intSet)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_btreeset_field() {
    // NOTE: BTreeSet<T> now maps to Set<T> in Kotlin with the new Format::Set variant.
    // This preserves the uniqueness constraint and provides better type safety.
    #[derive(Facet)]
    struct MyStruct {
        string_set: BTreeSet<String>,
        int_set: BTreeSet<i32>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var stringSet: Set<String>
        @Indirect public var intSet: Set<Int32>

        public init(stringSet: Set<String>, intSet: Set<Int32>) {
            self.stringSet = stringSet
            self.intSet = intSet
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeSet(value: self.stringSet, serializer: serializer) { item, serializer in
                try serializer.serialize_str(value: item)
            }
            try serializeSet(value: self.intSet, serializer: serializer) { item, serializer in
                try serializer.serialize_i32(value: item)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let stringSet = try deserializeSet(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let intSet = try deserializeSet(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_i32()
            }
            try deserializer.decrease_container_depth()
            return MyStruct(stringSet: stringSet, intSet: intSet)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_box_field() {
    #[derive(Facet)]
    #[allow(clippy::box_collection)]
    struct MyStruct {
        boxed_string: Box<String>,
        boxed_int: Box<i32>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var boxedString: String
        @Indirect public var boxedInt: Int32

        public init(boxedString: String, boxedInt: Int32) {
            self.boxedString = boxedString
            self.boxedInt = boxedInt
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.boxedString)
            try serializer.serialize_i32(value: self.boxedInt)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let boxedString = try deserializer.deserialize_str()
            let boxedInt = try deserializer.deserialize_i32()
            try deserializer.decrease_container_depth()
            return MyStruct(boxedString: boxedString, boxedInt: boxedInt)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_rc_field() {
    #[derive(Facet)]
    struct MyStruct {
        rc_string: Rc<String>,
        rc_int: Rc<i32>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var rcString: String
        @Indirect public var rcInt: Int32

        public init(rcString: String, rcInt: Int32) {
            self.rcString = rcString
            self.rcInt = rcInt
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.rcString)
            try serializer.serialize_i32(value: self.rcInt)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let rcString = try deserializer.deserialize_str()
            let rcInt = try deserializer.deserialize_i32()
            try deserializer.decrease_container_depth()
            return MyStruct(rcString: rcString, rcInt: rcInt)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_arc_field() {
    #[derive(Facet)]
    struct MyStruct {
        arc_string: Arc<String>,
        arc_int: Arc<i32>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var arcString: String
        @Indirect public var arcInt: Int32

        public init(arcString: String, arcInt: Int32) {
            self.arcString = arcString
            self.arcInt = arcInt
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.arcString)
            try serializer.serialize_i32(value: self.arcInt)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let arcString = try deserializer.deserialize_str()
            let arcInt = try deserializer.deserialize_i32()
            try deserializer.decrease_container_depth()
            return MyStruct(arcString: arcString, arcInt: arcInt)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_mixed_collections_and_pointers() {
    #[derive(Facet)]
    #[allow(clippy::box_collection)]
    struct MyStruct {
        vec_of_sets: Vec<HashSet<String>>,
        optional_btree: Option<BTreeMap<String, i32>>,
        boxed_vec: Box<Vec<String>>,
        arc_option: Arc<Option<String>>,
        array_of_boxes: [Box<i32>; 3],
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var vecOfSets: [Set<String>]
        @Indirect public var optionalBtree: [String: Int32]?
        @Indirect public var boxedVec: [String]
        @Indirect public var arcOption: String?
        @Indirect public var arrayOfBoxes: [Int32]

        public init(vecOfSets: [Set<String>], optionalBtree: [String: Int32]?, boxedVec: [String], arcOption: String?, arrayOfBoxes: [Int32]) {
            self.vecOfSets = vecOfSets
            self.optionalBtree = optionalBtree
            self.boxedVec = boxedVec
            self.arcOption = arcOption
            self.arrayOfBoxes = arrayOfBoxes
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeArray(value: self.vecOfSets, serializer: serializer) { item, serializer in
                try serializeSet(value: item, serializer: serializer) { item, serializer in
                    try serializer.serialize_str(value: item)
                }
            }
            try serializeOption(value: self.optionalBtree, serializer: serializer) { value, serializer in
                try serializeMap(value: value, serializer: serializer) { key, value, serializer in
                    try serializer.serialize_str(value: key)
                    try serializer.serialize_i32(value: value)
                }
            }
            try serializeArray(value: self.boxedVec, serializer: serializer) { item, serializer in
                try serializer.serialize_str(value: item)
            }
            try serializeOption(value: self.arcOption, serializer: serializer) { value, serializer in
                try serializer.serialize_str(value: value)
            }
            try serializeTupleArray(value: self.arrayOfBoxes, serializer: serializer) { item, serializer in
                try serializer.serialize_i32(value: item)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let vecOfSets = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializeSet(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_str()
                }
            }
            let optionalBtree = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializeMap(deserializer: deserializer) { deserializer in
                    let key = try deserializer.deserialize_str()
                    let value = try deserializer.deserialize_i32()
                    return (key, value)
                }
            }
            let boxedVec = try deserializeArray(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let arcOption = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializer.deserialize_str()
            }
            let arrayOfBoxes = try deserializeTupleArray(deserializer: deserializer, size: 3) { deserializer in
                try deserializer.deserialize_i32()
            }
            try deserializer.decrease_container_depth()
            return MyStruct(vecOfSets: vecOfSets, optionalBtree: optionalBtree, boxedVec: boxedVec, arcOption: arcOption, arrayOfBoxes: arrayOfBoxes)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_bytes_field() {
    #[derive(Facet)]
    struct MyStruct {
        #[facet(fg::bytes)]
        data: Vec<u8>,
        name: String,
        #[facet(fg::bytes)]
        header: Vec<u8>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var data: [UInt8]
        @Indirect public var name: String
        @Indirect public var header: [UInt8]

        public init(data: [UInt8], name: String, header: [UInt8]) {
            self.data = data
            self.name = name
            self.header = header
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_bytes(value: self.data)
            try serializer.serialize_str(value: self.name)
            try serializer.serialize_bytes(value: self.header)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let data = try deserializer.deserialize_bytes()
            let name = try deserializer.deserialize_str()
            let header = try deserializer.deserialize_bytes()
            try deserializer.decrease_container_depth()
            return MyStruct(data: data, name: name, header: header)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn struct_with_bytes_field_and_slice() {
    #[derive(Facet)]
    struct MyStruct<'a> {
        #[facet(fg::bytes)]
        data: &'a [u8],
        name: String,
        #[facet(fg::bytes)]
        header: Vec<u8>,
        optional_bytes: Option<Vec<u8>>,
    }

    let actual = emit!(MyStruct as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct MyStruct: Hashable {
        @Indirect public var data: [UInt8]
        @Indirect public var name: String
        @Indirect public var header: [UInt8]
        @Indirect public var optionalBytes: [UInt8]?

        public init(data: [UInt8], name: String, header: [UInt8], optionalBytes: [UInt8]?) {
            self.data = data
            self.name = name
            self.header = header
            self.optionalBytes = optionalBytes
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_bytes(value: self.data)
            try serializer.serialize_str(value: self.name)
            try serializer.serialize_bytes(value: self.header)
            try serializeOption(value: self.optionalBytes, serializer: serializer) { value, serializer in
                try serializeArray(value: value, serializer: serializer) { item, serializer in
                    try serializer.serialize_u8(value: item)
                }
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> MyStruct {
            try deserializer.increase_container_depth()
            let data = try deserializer.deserialize_bytes()
            let name = try deserializer.deserialize_str()
            let header = try deserializer.deserialize_bytes()
            let optionalBytes = try deserializeOption(deserializer: deserializer) { deserializer in
                try deserializeArray(deserializer: deserializer) { deserializer in
                    try deserializer.deserialize_u8()
                }
            }
            try deserializer.decrease_container_depth()
            return MyStruct(data: data, name: name, header: header, optionalBytes: optionalBytes)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> MyStruct {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}

#[test]
fn namespaced_child() {
    #[derive(Facet)]
    #[facet(fg::namespace = "Test")]
    struct Child {
        test: String,
    }

    #[derive(Facet)]
    struct Parent {
        child: Vec<Child>,
    }

    let actual = emit!(Parent as Swift with Encoding::Bincode).unwrap();
    insta::assert_snapshot!(actual, @r#"

    public struct Parent: Hashable {
        @Indirect public var child: [Test.Child]

        public init(child: [Test.Child]) {
            self.child = child
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializeArray(value: self.child, serializer: serializer) { item, serializer in
                try item.serialize(serializer: serializer)
            }
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Parent {
            try deserializer.increase_container_depth()
            let child = try deserializeArray(deserializer: deserializer) { deserializer in
                try Test.Child.deserialize(deserializer: deserializer)
            }
            try deserializer.decrease_container_depth()
            return Parent(child: child)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Parent {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }

    public struct Child: Hashable {
        @Indirect public var test: String

        public init(test: String) {
            self.test = test
        }

        public func serialize<S: Serializer>(serializer: S) throws {
            try serializer.increase_container_depth()
            try serializer.serialize_str(value: self.test)
            try serializer.decrease_container_depth()
        }

        public func bincodeSerialize() throws -> [UInt8] {
            let serializer = BincodeSerializer.init();
            try self.serialize(serializer: serializer)
            return serializer.get_bytes()
        }

        public static func deserialize<D: Deserializer>(deserializer: D) throws -> Child {
            try deserializer.increase_container_depth()
            let test = try deserializer.deserialize_str()
            try deserializer.decrease_container_depth()
            return Child(test: test)
        }

        public static func bincodeDeserialize(input: [UInt8]) throws -> Child {
            let deserializer = BincodeDeserializer.init(input: input);
            let obj = try deserialize(deserializer: deserializer)
            if deserializer.get_buffer_offset() < input.count {
                throw DeserializationError.invalidInput(issue: "Some input bytes were not read")
            }
            return obj
        }
    }
    "#);
}