rust-libteec 0.1.0

// SPDX-License-Identifier: Apache-2.0
// Copyright (C) 2025-2026 KylinSoft Co., Ltd. <https://www.kylinos.cn/>
// See LICENSES for license details.

#[cfg(test)]
mod protocol_tests {
    #[test]
    fn test_packet_header() {
        use cc_common::protocol::{PacketHeader, PacketType};
        use core::mem;

        let packet = PacketHeader {
            data_type: PacketType::OpenSession as u64,
            data_size: 1024,
        };

        // 测试协议头序列化和反序列化
        let bytes = packet.to_bytes();
        assert_eq!(bytes.len(), mem::size_of::<PacketHeader>());

        let new_packet = PacketHeader::from_bytes(bytes);
        assert_eq!(new_packet.data_type, packet.data_type);
        assert_eq!(new_packet.data_size, packet.data_size);
        assert_eq!(PacketHeader::SIZE, mem::size_of::<PacketHeader>());
    }

    #[test]
    fn test_packet_handler() {
        use cc_common::protocol::{PacketHeader, PacketType, CHUNK_SIZE};
        use core::mem;

        // 测试协议类型转换
        assert_eq!(PacketType::from(0), PacketType::Unknown);
        assert_eq!(PacketType::from(1), PacketType::OpenSession);
        assert_eq!(PacketType::from(2), PacketType::CloseSession);
        assert_eq!(PacketType::from(3), PacketType::InvokeCommand);
        assert_eq!(PacketType::from(4), PacketType::RequestCancellation);
        assert_eq!(PacketType::from(5), PacketType::Unknown);
        assert_eq!(PacketType::from(0xFFFFFFFF), PacketType::Unknown);

        assert_eq!(u64::from(PacketType::Unknown), 0);
        assert_eq!(u64::from(PacketType::OpenSession), 1);
        assert_eq!(u64::from(PacketType::CloseSession), 2);
        assert_eq!(u64::from(PacketType::InvokeCommand), 3);
        assert_eq!(u64::from(PacketType::RequestCancellation), 4);

        // 测试协议头数据大小
        let packet0 = PacketHeader {
            data_type: u64::from(PacketType::OpenSession),
            data_size: CHUNK_SIZE,
        };

        let packet1 = PacketHeader {
            data_type: u64::from(PacketType::CloseSession),
            data_size: 44,
        };

        assert_eq!(mem::size_of_val(&packet0), PacketHeader::SIZE);
        assert_eq!(mem::size_of_val(&packet1), PacketHeader::SIZE);
    }
}

#[cfg(test)]
mod psk_tests {
    use cc_common::psk::{generate_psk, get_psk_identity};

    #[test]
    fn test_psk_generation_success() {
        generate_psk().expect("生成PSK应该成功");
    }

    #[test]
    fn test_psk_deterministic() {
        let psk1 = generate_psk().expect("第一次生成 PSK 应该成功");
        let psk2 = generate_psk().expect("第二次生成 PSK 应该成功");
        assert_eq!(psk1, psk2);
    }

    #[test]
    fn test_psk_length() {
        let psk = generate_psk().expect("生成 PSK 应该成功");
        assert_eq!(psk.len(), 32, "PSK 长度应该为 32 字节");
    }

    #[test]
    fn test_psk_not_all_zero() {
        let psk = generate_psk().expect("生成 PSK 应该成功");
        assert!(psk.iter().any(|&b| b != 0), "PSK 不应该全为零");
    }

    #[test]
    fn test_psk_identity_not_empty() {
        let identity = get_psk_identity();
        assert!(!identity.is_empty());
    }

    #[test]
    fn test_psk_identity_correct_value() {
        let identity = get_psk_identity();
        assert_eq!(identity, "cc-utils");
    }
}