clang_ast_parser.rs

use cpprustser_lib::clang_parser::parse_header_with_clang;
use cpprustser_lib::schema::Schema;

#[test]
fn parses_real_ast_json_record_and_enum() {
    let json = r#"{
        "kind": "TranslationUnitDecl",
        "inner": [
            {
                "kind": "RecordDecl",
                "name": "Person",
                "inner": [
                    { "kind": "FieldDecl", "name": "id", "type": { "qualType": "int" } },
                    { "kind": "FieldDecl", "name": "name", "type": { "qualType": "std::string" } },
                    { "kind": "FieldDecl", "name": "active", "type": { "qualType": "bool" } },
                    { "kind": "FieldDecl", "name": "role", "type": { "qualType": "Role" } }
                ]
            },
            {
                "kind": "EnumDecl",
                "name": "Role",
                "inner": [
                    { "kind": "EnumConstantDecl", "name": "Admin", "value": 0 },
                    { "kind": "EnumConstantDecl", "name": "User", "value": 1 },
                    { "kind": "EnumConstantDecl", "name": "Guest", "value": 2 }
                ]
            }
        ]
    }"#;

    let schema = Schema::parse_clang_ast_json(json);
    assert!(schema.structs.contains_key("Person"));
    assert!(schema.enums.contains_key("Role"));
    assert_eq!(schema.structs["Person"].fields.len(), 4);
    assert_eq!(schema.structs["Person"].fields[3].ty, "Role");
    assert_eq!(schema.enums["Role"].members.len(), 3);
}

#[test]
fn parses_header_without_regex_fallback() {
    let text = r#"
        enum class Role {
            Admin = 0,
            User = 1,
            Guest = 2
        };

        struct Person {
            int id;
            std::string name;
            bool active;
            Role role;
        };
    "#;

    let schema = Schema::parse_header(text);
    assert!(schema.structs.contains_key("Person"));
    assert!(schema.enums.contains_key("Role"));
    assert_eq!(schema.structs["Person"].fields[3].ty, "Role");
}

#[test]
fn parses_company_from_example_header_with_real_clang() {
    let header = concat!(env!("CARGO_MANIFEST_DIR"), "/example.h");
    let schema = parse_header_with_clang(header).expect("Clang should parse example.h");

    let company = &schema.structs["Company"];
    assert_eq!(company.fields.len(), 2);
    assert_eq!(company.fields[0].name, "name");
    assert_eq!(company.fields[0].ty, "std::string");
    assert_eq!(company.fields[1].name, "employees");
    assert_eq!(company.fields[1].ty, "std::vector<Person>");

    let value = serde_json::json!({
        "name": "Acme",
        "employees": [
            {"id": 42, "name": "Alice", "active": true, "role": "Admin"},
            {"id": 7, "name": "Bob", "active": false, "role": "User"}
        ]
    });
    assert_eq!(schema.serialize_for_type("Company", &value), Ok(value));
}

#[test]
fn parses_cpp20_features_with_real_clang() {
    let header = concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/tests/fixtures/cpp20_features.hpp"
    );
    let schema = parse_header_with_clang(header).expect("Clang should parse the C++20 fixture");

    assert!(schema.structs.contains_key("demo::model::Entity"));
    assert!(schema.structs.contains_key("demo::model::User"));
    assert!(schema.structs.contains_key("demo::model::User::Address"));
    assert!(schema.enums.contains_key("demo::model::Access"));
    assert!(schema.enums.contains_key("demo::model::User::State"));
    assert!(schema.aliases.contains_key("demo::model::UserId"));
    assert!(!schema.enums.contains_key("std::byte"));

    let user = &schema.structs["demo::model::User"];
    assert_eq!(user.kind, "class");
    assert_eq!(user.bases[0].ty, "Entity");
    assert!(user
        .fields
        .iter()
        .any(|field| field.ty == "std::vector<int>"));
    assert!(user.fields.iter().any(|field| field.ty == "const Entity *"));
    assert!(user.fields.iter().any(|field| field.ty == "int (&)[2][3]"));
    assert!(user
        .fields
        .iter()
        .any(|field| field.name == "flags" && field.is_bitfield));

    let access = &schema.enums["demo::model::Access"];
    assert!(access.scoped);
    assert_eq!(access.underlying_type.as_deref(), Some("std::uint8_t"));
    assert_eq!(access.members[2].value, Some(4));

    let value = serde_json::json!({
        "name": "Alice",
        "access": "Admin",
        "address": {"city": "Paris", "postal_code": "75000000"},
        "state": "Active",
        "scores": [10, 20],
        "nickname": null,
        "manager": null,
        "matrix": [[1, 2, 3], [4, 5, 6]],
        "flags": 3
    });
    assert_eq!(
        schema.serialize_for_type("demo::model::User", &value),
        Ok(value)
    );
}