kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg-ffi/src/validation.rs

@@ -1,848 +0,0 @@
-//! Configuration validation FFI module.
-//!
-//! Exposes validation functions from `kreuzberg::core::config_validation` through C FFI,
-//! allowing all language bindings (Python, Java, TypeScript, Ruby, Go, C#) to validate
-//! configuration values without duplicating validation logic.
-//!
-//! # Return Values
-//!
-//! All validator functions return:
-//! - `1` if the value is valid
-//! - `0` if the value is invalid (with error message set via `set_last_error()`)
-//!
-//! # String Functions
-//!
-//! List functions return JSON-encoded strings as `*mut c_char` that MUST be freed by the caller
-//! using `kreuzberg_free_string()`.
-//!
-//! # Examples (in C)
-//!
-//! ```c
-//! // Validate a string parameter
-//! if (kreuzberg_validate_binarization_method("otsu") == 1) {
-//!     printf("Valid!\n");
-//! } else {
-//!     printf("Error: %s\n", kreuzberg_get_last_error_message());
-//! }
-//!
-//! // Get valid options
-//! char* methods = kreuzberg_get_valid_binarization_methods();
-//! // Use it...
-//! kreuzberg_free_string(methods);
-//! ```
-
-use std::ffi::CStr;
-use std::os::raw::c_char;
-
-use kreuzberg::core::config_validation::{
-    validate_binarization_method, validate_chunking_params, validate_confidence, validate_dpi, validate_language_code,
-    validate_ocr_backend, validate_output_format, validate_tesseract_oem, validate_tesseract_psm,
-    validate_token_reduction_level,
-};
-
-use crate::set_last_error;
-
-const VALID_BINARIZATION_METHODS: &[&str] = &["otsu", "adaptive", "sauvola"];
-const VALID_TOKEN_REDUCTION_LEVELS: &[&str] = &["off", "light", "moderate", "aggressive", "maximum"];
-const VALID_OCR_BACKENDS: &[&str] = &["tesseract", "easyocr", "paddleocr"];
-const VALID_LANGUAGE_CODES: &[&str] = &[
-    "en", "de", "fr", "es", "it", "pt", "nl", "pl", "ru", "zh", "ja", "ko", "bg", "cs", "da", "el", "et", "fi", "hu",
-    "lt", "lv", "ro", "sk", "sl", "sv", "uk", "ar", "hi", "th", "tr", "vi", "eng", "deu", "fra", "spa", "ita", "por",
-    "nld", "pol", "rus", "zho", "jpn", "kor", "ces", "dan", "ell", "est", "fin", "hun", "lit", "lav", "ron", "slk",
-    "slv", "swe", "tur",
-];
-
-/// Validates a binarization method string.
-///
-/// # Arguments
-///
-/// * `method` - C string containing the binarization method (e.g., "otsu", "adaptive", "sauvola")
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # Safety
-///
-/// * `method` must be a valid pointer to a null-terminated UTF-8 string
-/// * `method` cannot be NULL
-/// * The string must be valid for the duration of the call
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_binarization_method(const char* method);
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_binarization_method(method: *const c_char) -> i32 {
-    if method.is_null() {
-        set_last_error("method cannot be NULL".to_string());
-        return 0;
-    }
-
-    let method_str = match unsafe { CStr::from_ptr(method) }.to_str() {
-        Ok(s) => s,
-        Err(_) => {
-            set_last_error("Invalid UTF-8 in method".to_string());
-            return 0;
-        }
-    };
-
-    match validate_binarization_method(method_str) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates an OCR backend string.
-///
-/// # Arguments
-///
-/// * `backend` - C string containing the OCR backend (e.g., "tesseract", "easyocr", "paddleocr")
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # Safety
-///
-/// * `backend` must be a valid pointer to a null-terminated UTF-8 string
-/// * `backend` cannot be NULL
-/// * The string must be valid for the duration of the call
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_ocr_backend(const char* backend);
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_ocr_backend(backend: *const c_char) -> i32 {
-    if backend.is_null() {
-        set_last_error("backend cannot be NULL".to_string());
-        return 0;
-    }
-
-    let backend_str = match unsafe { CStr::from_ptr(backend) }.to_str() {
-        Ok(s) => s,
-        Err(_) => {
-            set_last_error("Invalid UTF-8 in backend".to_string());
-            return 0;
-        }
-    };
-
-    match validate_ocr_backend(backend_str) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a language code (ISO 639-1 or 639-3 format).
-///
-/// Accepts both 2-letter codes (e.g., "en", "de") and 3-letter codes (e.g., "eng", "deu").
-///
-/// # Arguments
-///
-/// * `code` - C string containing the language code
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # Safety
-///
-/// * `code` must be a valid pointer to a null-terminated UTF-8 string
-/// * `code` cannot be NULL
-/// * The string must be valid for the duration of the call
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_language_code(const char* code);
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_language_code(code: *const c_char) -> i32 {
-    if code.is_null() {
-        set_last_error("code cannot be NULL".to_string());
-        return 0;
-    }
-
-    let code_str = match unsafe { CStr::from_ptr(code) }.to_str() {
-        Ok(s) => s,
-        Err(_) => {
-            set_last_error("Invalid UTF-8 in code".to_string());
-            return 0;
-        }
-    };
-
-    match validate_language_code(code_str) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a token reduction level string.
-///
-/// # Arguments
-///
-/// * `level` - C string containing the token reduction level (e.g., "off", "light", "moderate")
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # Safety
-///
-/// * `level` must be a valid pointer to a null-terminated UTF-8 string
-/// * `level` cannot be NULL
-/// * The string must be valid for the duration of the call
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_token_reduction_level(const char* level);
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_token_reduction_level(level: *const c_char) -> i32 {
-    if level.is_null() {
-        set_last_error("level cannot be NULL".to_string());
-        return 0;
-    }
-
-    let level_str = match unsafe { CStr::from_ptr(level) }.to_str() {
-        Ok(s) => s,
-        Err(_) => {
-            set_last_error("Invalid UTF-8 in level".to_string());
-            return 0;
-        }
-    };
-
-    match validate_token_reduction_level(level_str) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a tesseract Page Segmentation Mode (PSM) value.
-///
-/// # Arguments
-///
-/// * `psm` - PSM value (valid range: 0-13)
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_tesseract_psm(int32_t psm);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_validate_tesseract_psm(psm: i32) -> i32 {
-    match validate_tesseract_psm(psm) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a tesseract OCR Engine Mode (OEM) value.
-///
-/// # Arguments
-///
-/// * `oem` - OEM value (valid range: 0-3)
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_tesseract_oem(int32_t oem);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_validate_tesseract_oem(oem: i32) -> i32 {
-    match validate_tesseract_oem(oem) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a tesseract output format string.
-///
-/// # Arguments
-///
-/// * `format` - C string containing the output format (e.g., "text", "markdown")
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # Safety
-///
-/// * `format` must be a valid pointer to a null-terminated UTF-8 string
-/// * `format` cannot be NULL
-/// * The string must be valid for the duration of the call
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_output_format(const char* format);
-/// ```
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn kreuzberg_validate_output_format(format: *const c_char) -> i32 {
-    if format.is_null() {
-        set_last_error("format cannot be NULL".to_string());
-        return 0;
-    }
-
-    let format_str = match unsafe { CStr::from_ptr(format) }.to_str() {
-        Ok(s) => s,
-        Err(_) => {
-            set_last_error("Invalid UTF-8 in format".to_string());
-            return 0;
-        }
-    };
-
-    match validate_output_format(format_str) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a confidence threshold value.
-///
-/// Confidence thresholds must be between 0.0 and 1.0 inclusive.
-///
-/// # Arguments
-///
-/// * `confidence` - Confidence threshold value
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_confidence(double confidence);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_validate_confidence(confidence: f64) -> i32 {
-    match validate_confidence(confidence) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates a DPI (dots per inch) value.
-///
-/// DPI must be a positive integer, typically 72-600.
-///
-/// # Arguments
-///
-/// * `dpi` - DPI value
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_dpi(int32_t dpi);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_validate_dpi(dpi: i32) -> i32 {
-    match validate_dpi(dpi) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Validates chunking parameters.
-///
-/// Checks that `max_chars > 0` and `max_overlap < max_chars`.
-///
-/// # Arguments
-///
-/// * `max_chars` - Maximum characters per chunk
-/// * `max_overlap` - Maximum overlap between chunks
-///
-/// # Returns
-///
-/// - `1` if valid
-/// - `0` if invalid (error message available via `kreuzberg_get_last_error_message()`)
-///
-/// # C Signature
-///
-/// ```c
-/// int32_t kreuzberg_validate_chunking_params(size_t max_chars, size_t max_overlap);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_validate_chunking_params(max_chars: usize, max_overlap: usize) -> i32 {
-    match validate_chunking_params(max_chars, max_overlap) {
-        Ok(()) => 1,
-        Err(e) => {
-            set_last_error(e.to_string());
-            0
-        }
-    }
-}
-
-/// Returns valid binarization methods as a JSON array string.
-///
-/// The returned string MUST be freed by the caller using `kreuzberg_free_string()`.
-///
-/// # Returns
-///
-/// A pointer to a dynamically allocated C string containing a JSON array of valid methods.
-/// Returns NULL if memory allocation fails (error message set via `set_last_error()`).
-///
-/// # Example
-///
-/// The returned JSON string looks like: `["otsu","adaptive","sauvola"]`
-///
-/// # C Signature
-///
-/// ```c
-/// char* kreuzberg_get_valid_binarization_methods(void);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_get_valid_binarization_methods() -> *mut c_char {
-    let json = format!(
-        "[{}]",
-        VALID_BINARIZATION_METHODS
-            .iter()
-            .map(|m| format!("\"{}\"", m))
-            .collect::<Vec<_>>()
-            .join(",")
-    );
-
-    match std::ffi::CString::new(json) {
-        Ok(c_str) => c_str.into_raw(),
-        Err(e) => {
-            set_last_error(format!("Failed to allocate string: {}", e));
-            std::ptr::null_mut()
-        }
-    }
-}
-
-/// Returns valid language codes as a JSON array string.
-///
-/// The returned string MUST be freed by the caller using `kreuzberg_free_string()`.
-///
-/// # Returns
-///
-/// A pointer to a dynamically allocated C string containing a JSON array of valid codes.
-/// Returns NULL if memory allocation fails (error message set via `set_last_error()`).
-///
-/// # C Signature
-///
-/// ```c
-/// char* kreuzberg_get_valid_language_codes(void);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_get_valid_language_codes() -> *mut c_char {
-    let json = format!(
-        "[{}]",
-        VALID_LANGUAGE_CODES
-            .iter()
-            .map(|c| format!("\"{}\"", c))
-            .collect::<Vec<_>>()
-            .join(",")
-    );
-
-    match std::ffi::CString::new(json) {
-        Ok(c_str) => c_str.into_raw(),
-        Err(e) => {
-            set_last_error(format!("Failed to allocate string: {}", e));
-            std::ptr::null_mut()
-        }
-    }
-}
-
-/// Returns valid OCR backends as a JSON array string.
-///
-/// The returned string MUST be freed by the caller using `kreuzberg_free_string()`.
-///
-/// # Returns
-///
-/// A pointer to a dynamically allocated C string containing a JSON array of valid backends.
-/// Returns NULL if memory allocation fails (error message set via `set_last_error()`).
-///
-/// # C Signature
-///
-/// ```c
-/// char* kreuzberg_get_valid_ocr_backends(void);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_get_valid_ocr_backends() -> *mut c_char {
-    let json = format!(
-        "[{}]",
-        VALID_OCR_BACKENDS
-            .iter()
-            .map(|b| format!("\"{}\"", b))
-            .collect::<Vec<_>>()
-            .join(",")
-    );
-
-    match std::ffi::CString::new(json) {
-        Ok(c_str) => c_str.into_raw(),
-        Err(e) => {
-            set_last_error(format!("Failed to allocate string: {}", e));
-            std::ptr::null_mut()
-        }
-    }
-}
-
-/// Returns valid token reduction levels as a JSON array string.
-///
-/// The returned string MUST be freed by the caller using `kreuzberg_free_string()`.
-///
-/// # Returns
-///
-/// A pointer to a dynamically allocated C string containing a JSON array of valid levels.
-/// Returns NULL if memory allocation fails (error message set via `set_last_error()`).
-///
-/// # C Signature
-///
-/// ```c
-/// char* kreuzberg_get_valid_token_reduction_levels(void);
-/// ```
-#[unsafe(no_mangle)]
-pub extern "C" fn kreuzberg_get_valid_token_reduction_levels() -> *mut c_char {
-    let json = format!(
-        "[{}]",
-        VALID_TOKEN_REDUCTION_LEVELS
-            .iter()
-            .map(|l| format!("\"{}\"", l))
-            .collect::<Vec<_>>()
-            .join(",")
-    );
-
-    match std::ffi::CString::new(json) {
-        Ok(c_str) => c_str.into_raw(),
-        Err(e) => {
-            set_last_error(format!("Failed to allocate string: {}", e));
-            std::ptr::null_mut()
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_validate_binarization_method_valid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_binarization_method(c"otsu".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_binarization_method(c"adaptive".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_binarization_method(c"sauvola".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_binarization_method_invalid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_binarization_method(c"invalid".as_ptr()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_binarization_method_null() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_binarization_method(std::ptr::null()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_ocr_backend_valid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_ocr_backend(c"tesseract".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_ocr_backend(c"easyocr".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_ocr_backend(c"paddleocr".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_ocr_backend_invalid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_ocr_backend(c"invalid_backend".as_ptr()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_ocr_backend_null() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_ocr_backend(std::ptr::null()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_language_code_valid_2letter() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_language_code(c"en".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_language_code(c"de".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_language_code(c"fr".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_language_code_valid_3letter() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_language_code(c"eng".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_language_code(c"deu".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_language_code(c"fra".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_language_code_invalid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_language_code(c"invalid".as_ptr()), 0);
-            assert_eq!(kreuzberg_validate_language_code(c"xx".as_ptr()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_language_code_null() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_language_code(std::ptr::null()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_token_reduction_level_valid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"off".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"light".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"moderate".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"aggressive".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"maximum".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_token_reduction_level_invalid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_token_reduction_level(c"extreme".as_ptr()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_token_reduction_level_null() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_token_reduction_level(std::ptr::null()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_tesseract_psm_valid() {
-        for psm in 0..=13 {
-            assert_eq!(kreuzberg_validate_tesseract_psm(psm), 1, "PSM {} should be valid", psm);
-        }
-    }
-
-    #[test]
-    fn test_validate_tesseract_psm_invalid() {
-        assert_eq!(kreuzberg_validate_tesseract_psm(-1), 0);
-        assert_eq!(kreuzberg_validate_tesseract_psm(14), 0);
-        assert_eq!(kreuzberg_validate_tesseract_psm(100), 0);
-    }
-
-    #[test]
-    fn test_validate_tesseract_oem_valid() {
-        for oem in 0..=3 {
-            assert_eq!(kreuzberg_validate_tesseract_oem(oem), 1, "OEM {} should be valid", oem);
-        }
-    }
-
-    #[test]
-    fn test_validate_tesseract_oem_invalid() {
-        assert_eq!(kreuzberg_validate_tesseract_oem(-1), 0);
-        assert_eq!(kreuzberg_validate_tesseract_oem(4), 0);
-        assert_eq!(kreuzberg_validate_tesseract_oem(10), 0);
-    }
-
-    #[test]
-    fn test_validate_output_format_valid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_output_format(c"text".as_ptr()), 1);
-            assert_eq!(kreuzberg_validate_output_format(c"markdown".as_ptr()), 1);
-        }
-    }
-
-    #[test]
-    fn test_validate_output_format_invalid() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_output_format(c"json".as_ptr()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_output_format_null() {
-        unsafe {
-            assert_eq!(kreuzberg_validate_output_format(std::ptr::null()), 0);
-        }
-    }
-
-    #[test]
-    fn test_validate_confidence_valid() {
-        assert_eq!(kreuzberg_validate_confidence(0.0), 1);
-        assert_eq!(kreuzberg_validate_confidence(0.5), 1);
-        assert_eq!(kreuzberg_validate_confidence(1.0), 1);
-    }
-
-    #[test]
-    fn test_validate_confidence_invalid() {
-        assert_eq!(kreuzberg_validate_confidence(-0.1), 0);
-        assert_eq!(kreuzberg_validate_confidence(1.1), 0);
-        assert_eq!(kreuzberg_validate_confidence(2.0), 0);
-    }
-
-    #[test]
-    fn test_validate_dpi_valid() {
-        assert_eq!(kreuzberg_validate_dpi(72), 1);
-        assert_eq!(kreuzberg_validate_dpi(96), 1);
-        assert_eq!(kreuzberg_validate_dpi(300), 1);
-        assert_eq!(kreuzberg_validate_dpi(600), 1);
-    }
-
-    #[test]
-    fn test_validate_dpi_invalid() {
-        assert_eq!(kreuzberg_validate_dpi(0), 0);
-        assert_eq!(kreuzberg_validate_dpi(-1), 0);
-        assert_eq!(kreuzberg_validate_dpi(2401), 0);
-    }
-
-    #[test]
-    fn test_validate_chunking_params_valid() {
-        assert_eq!(kreuzberg_validate_chunking_params(1000, 200), 1);
-        assert_eq!(kreuzberg_validate_chunking_params(500, 50), 1);
-        assert_eq!(kreuzberg_validate_chunking_params(1, 0), 1);
-    }
-
-    #[test]
-    fn test_validate_chunking_params_invalid_zero_chars() {
-        assert_eq!(kreuzberg_validate_chunking_params(0, 100), 0);
-    }
-
-    #[test]
-    fn test_validate_chunking_params_invalid_overlap() {
-        assert_eq!(kreuzberg_validate_chunking_params(100, 100), 0);
-        assert_eq!(kreuzberg_validate_chunking_params(100, 150), 0);
-    }
-
-    #[test]
-    fn test_get_valid_binarization_methods() {
-        unsafe {
-            let json_ptr = kreuzberg_get_valid_binarization_methods();
-            assert!(!json_ptr.is_null(), "Should return non-null pointer");
-
-            let c_str = CStr::from_ptr(json_ptr);
-            let json_str = c_str.to_str().expect("Should be valid UTF-8");
-
-            assert!(json_str.contains("otsu"));
-            assert!(json_str.contains("adaptive"));
-            assert!(json_str.contains("sauvola"));
-            assert!(json_str.starts_with('[') && json_str.ends_with(']'));
-
-            let _ = std::ffi::CString::from_raw(json_ptr as *mut c_char);
-        }
-    }
-
-    #[test]
-    fn test_get_valid_language_codes() {
-        unsafe {
-            let json_ptr = kreuzberg_get_valid_language_codes();
-            assert!(!json_ptr.is_null(), "Should return non-null pointer");
-
-            let c_str = CStr::from_ptr(json_ptr);
-            let json_str = c_str.to_str().expect("Should be valid UTF-8");
-
-            assert!(json_str.contains("en"));
-            assert!(json_str.contains("de"));
-            assert!(json_str.contains("eng"));
-            assert!(json_str.contains("deu"));
-            assert!(json_str.starts_with('[') && json_str.ends_with(']'));
-
-            let _ = std::ffi::CString::from_raw(json_ptr as *mut c_char);
-        }
-    }
-
-    #[test]
-    fn test_get_valid_ocr_backends() {
-        unsafe {
-            let json_ptr = kreuzberg_get_valid_ocr_backends();
-            assert!(!json_ptr.is_null(), "Should return non-null pointer");
-
-            let c_str = CStr::from_ptr(json_ptr);
-            let json_str = c_str.to_str().expect("Should be valid UTF-8");
-
-            assert!(json_str.contains("tesseract"));
-            assert!(json_str.contains("easyocr"));
-            assert!(json_str.contains("paddleocr"));
-            assert!(json_str.starts_with('[') && json_str.ends_with(']'));
-
-            let _ = std::ffi::CString::from_raw(json_ptr as *mut c_char);
-        }
-    }
-
-    #[test]
-    fn test_get_valid_token_reduction_levels() {
-        unsafe {
-            let json_ptr = kreuzberg_get_valid_token_reduction_levels();
-            assert!(!json_ptr.is_null(), "Should return non-null pointer");
-
-            let c_str = CStr::from_ptr(json_ptr);
-            let json_str = c_str.to_str().expect("Should be valid UTF-8");
-
-            assert!(json_str.contains("off"));
-            assert!(json_str.contains("light"));
-            assert!(json_str.contains("moderate"));
-            assert!(json_str.contains("aggressive"));
-            assert!(json_str.contains("maximum"));
-            assert!(json_str.starts_with('[') && json_str.ends_with(']'));
-
-            let _ = std::ffi::CString::from_raw(json_ptr as *mut c_char);
-        }
-    }
-}