xberg 1.0.0

High-performance document intelligence library for Rust. Extract text, metadata, and structured data from PDFs, Office documents, images, and 98 formats and 306 programming languages via tree-sitter code intelligence with async/sync APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Cross-language serialization integration tests.
//!
//! These tests validate that ExtractionConfig serializes correctly
//! and that the serialized output can be used for cross-language comparison.

use xberg::core::config::ExtractionConfig;

#[test]
fn test_extraction_config_minimal_serialization() {
    let config = ExtractionConfig::default();
    let json = serde_json::to_value(&config).expect("Failed to serialize config");

    assert!(json.get("use_cache").is_some(), "Missing use_cache field");
    assert!(
        json.get("enable_quality_processing").is_some(),
        "Missing enable_quality_processing field"
    );
    assert!(json.get("force_ocr").is_some(), "Missing force_ocr field");
}

#[test]
fn test_extraction_config_serialization_round_trip() {
    let original = ExtractionConfig {
        use_cache: true,
        enable_quality_processing: false,
        force_ocr: true,
        ..Default::default()
    };

    let json = serde_json::to_value(&original).expect("Failed to serialize");

    let restored: ExtractionConfig = serde_json::from_value(json).expect("Failed to deserialize");

    assert_eq!(original.use_cache, restored.use_cache, "use_cache field not preserved");
    assert_eq!(
        original.enable_quality_processing, restored.enable_quality_processing,
        "enable_quality_processing field not preserved"
    );
    assert_eq!(original.force_ocr, restored.force_ocr, "force_ocr field not preserved");
}

#[test]
fn test_extraction_config_nested_serialization() {
    let config = ExtractionConfig {
        use_cache: true,
        enable_quality_processing: true,
        force_ocr: false,
        ..Default::default()
    };

    let json = serde_json::to_value(&config).expect("Failed to serialize");

    assert!(json.is_object(), "Serialized output should be a JSON object");

    assert!(json.get("use_cache").is_some());
    assert!(json.get("enable_quality_processing").is_some());
    assert!(json.get("force_ocr").is_some());
}

#[test]
fn test_extraction_config_json_format() {
    let config = ExtractionConfig::default();
    let json_string = serde_json::to_string(&config).expect("Failed to serialize to string");

    let parsed: serde_json::Value = serde_json::from_str(&json_string).expect("Invalid JSON output");
    assert!(parsed.is_object(), "JSON should be an object");
}

#[test]
fn test_extraction_config_pretty_print() {
    let config = ExtractionConfig::default();
    let pretty_json = serde_json::to_string_pretty(&config).expect("Failed to serialize");

    let _parsed: serde_json::Value = serde_json::from_str(&pretty_json).expect("Invalid pretty-printed JSON");

    assert!(pretty_json.contains('\n'), "Pretty JSON should have newlines");
}

#[test]
fn test_extraction_config_field_consistency() {
    let configs = vec![
        ExtractionConfig::default(),
        ExtractionConfig {
            use_cache: true,
            ..Default::default()
        },
        ExtractionConfig {
            enable_quality_processing: false,
            ..Default::default()
        },
    ];

    for config in configs {
        let json = serde_json::to_value(&config).expect("Failed to serialize");

        assert!(json.get("use_cache").is_some());
        assert!(json.get("enable_quality_processing").is_some());
        assert!(json.get("force_ocr").is_some());
    }
}