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

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

@@ -1,977 +0,0 @@
-//! C FFI bindings for Kreuzberg document intelligence library.
-//!
-//! Provides a C-compatible API that can be consumed by Java (Panama FFI),
-//! Go (cgo), C# (P/Invoke), Zig, and other languages with C FFI support.
-
-mod batch_streaming;
-mod config;
-mod error;
-mod extraction;
-mod helpers;
-mod memory;
-mod mime;
-mod panic_shield;
-mod plugins;
-mod result;
-mod result_pool;
-mod result_view;
-mod string_intern;
-mod types;
-mod util;
-mod validation;
-
-pub use batch_streaming::{
-    ErrorCallback, ResultCallback, kreuzberg_extract_batch_parallel, kreuzberg_extract_batch_streaming,
-};
-pub use config::{
-    kreuzberg_config_discover, kreuzberg_config_free, kreuzberg_config_from_file, kreuzberg_config_from_json,
-    kreuzberg_config_get_field, kreuzberg_config_is_valid, kreuzberg_config_merge, kreuzberg_config_to_json,
-    kreuzberg_get_embedding_preset, kreuzberg_list_embedding_presets, kreuzberg_load_extraction_config_from_file,
-};
-pub use error::ErrorCode as KreuzbergErrorCode;
-pub use error::{
-    CErrorDetails, kreuzberg_classify_error, kreuzberg_error_code_count, kreuzberg_error_code_description,
-    kreuzberg_error_code_internal, kreuzberg_error_code_io, kreuzberg_error_code_missing_dependency,
-    kreuzberg_error_code_name, kreuzberg_error_code_ocr, kreuzberg_error_code_parsing, kreuzberg_error_code_plugin,
-    kreuzberg_error_code_unsupported_format, kreuzberg_error_code_validation, kreuzberg_get_error_details,
-};
-pub use extraction::{
-    kreuzberg_batch_extract_bytes_sync, kreuzberg_batch_extract_files_sync, kreuzberg_extract_bytes_sync,
-    kreuzberg_extract_bytes_sync_with_config, kreuzberg_extract_file_sync, kreuzberg_extract_file_sync_with_config,
-};
-pub use helpers::*;
-pub use memory::{kreuzberg_clone_string, kreuzberg_free_batch_result, kreuzberg_free_result, kreuzberg_free_string};
-pub use mime::{
-    kreuzberg_detect_mime_type, kreuzberg_detect_mime_type_from_bytes, kreuzberg_detect_mime_type_from_path,
-    kreuzberg_get_extensions_for_mime, kreuzberg_validate_mime_type,
-};
-pub use panic_shield::{
-    ErrorCode, StructuredError, clear_structured_error, get_last_error_code, get_last_error_message,
-    get_last_panic_context, set_structured_error,
-};
-pub use plugins::*;
-pub use result::{
-    CMetadataField, kreuzberg_result_get_chunk_count, kreuzberg_result_get_detected_language,
-    kreuzberg_result_get_metadata_field, kreuzberg_result_get_page_count,
-};
-pub use result_pool::{
-    CResultPoolStats, ResultPool, kreuzberg_extract_file_into_pool, kreuzberg_extract_file_into_pool_view,
-    kreuzberg_result_pool_free, kreuzberg_result_pool_new, kreuzberg_result_pool_reset, kreuzberg_result_pool_stats,
-};
-pub use result_view::{
-    CExtractionResultView, kreuzberg_get_result_view, kreuzberg_view_get_content, kreuzberg_view_get_mime_type,
-};
-pub use string_intern::{
-    CStringInternStats, kreuzberg_free_interned_string, kreuzberg_intern_string, kreuzberg_string_intern_reset,
-    kreuzberg_string_intern_stats,
-};
-pub use types::*;
-pub use util::{kreuzberg_last_error, kreuzberg_last_error_code, kreuzberg_last_panic_context, kreuzberg_version};
-pub use validation::*;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ffi::{CStr, CString};
-    use std::os::raw::c_char;
-    use std::ptr;
-
-    #[test]
-    fn test_version() {
-        unsafe {
-            let version = kreuzberg_version();
-            assert!(!version.is_null());
-            let version_str = CStr::from_ptr(version).to_str().unwrap();
-            assert!(!version_str.is_empty());
-        }
-    }
-
-    #[test]
-    fn test_null_path() {
-        unsafe {
-            let result = kreuzberg_extract_file_sync(ptr::null());
-            assert!(result.is_null());
-
-            let error = kreuzberg_last_error();
-            assert!(!error.is_null());
-            let error_str = CStr::from_ptr(error).to_str().unwrap();
-            assert!(error_str.contains("NULL"));
-        }
-    }
-
-    #[test]
-    fn test_nonexistent_file() {
-        unsafe {
-            let path = CString::new("/nonexistent/file.pdf").unwrap();
-            let result = kreuzberg_extract_file_sync(path.as_ptr());
-            assert!(result.is_null());
-
-            let error = kreuzberg_last_error();
-            assert!(!error.is_null());
-        }
-    }
-
-    // ==================== Struct Layout Tests ====================
-
-    #[test]
-    fn test_cextraction_result_layout() {
-        // Test size
-        assert_eq!(
-            std::mem::size_of::<CExtractionResult>(),
-            104,
-            "CExtractionResult must be exactly 104 bytes"
-        );
-
-        // Test alignment
-        assert_eq!(
-            std::mem::align_of::<CExtractionResult>(),
-            8,
-            "CExtractionResult must be 8-byte aligned"
-        );
-    }
-
-    #[test]
-    fn test_cbatch_result_layout() {
-        // Test size
-        assert_eq!(
-            std::mem::size_of::<CBatchResult>(),
-            24,
-            "CBatchResult must be exactly 24 bytes"
-        );
-
-        // Test alignment
-        assert_eq!(
-            std::mem::align_of::<CBatchResult>(),
-            8,
-            "CBatchResult must be 8-byte aligned"
-        );
-    }
-
-    #[test]
-    fn test_cbytes_with_mime_layout() {
-        // Test size
-        assert_eq!(
-            std::mem::size_of::<CBytesWithMime>(),
-            24,
-            "CBytesWithMime must be exactly 24 bytes"
-        );
-
-        // Test alignment
-        assert_eq!(
-            std::mem::align_of::<CBytesWithMime>(),
-            8,
-            "CBytesWithMime must be 8-byte aligned"
-        );
-    }
-
-    // ==================== Memory Safety Tests ====================
-
-    /// Helper function to create a mock CExtractionResult for testing
-    fn create_mock_extraction_result() -> *mut CExtractionResult {
-        Box::into_raw(Box::new(CExtractionResult {
-            content: CString::new("test content").unwrap().into_raw(),
-            mime_type: CString::new("text/plain").unwrap().into_raw(),
-            language: CString::new("en").unwrap().into_raw(),
-            date: ptr::null_mut(),
-            subject: ptr::null_mut(),
-            tables_json: ptr::null_mut(),
-            detected_languages_json: ptr::null_mut(),
-            metadata_json: ptr::null_mut(),
-            chunks_json: ptr::null_mut(),
-            images_json: ptr::null_mut(),
-            page_structure_json: ptr::null_mut(),
-            pages_json: ptr::null_mut(),
-            success: true,
-            _padding1: [0u8; 7],
-        }))
-    }
-
-    #[test]
-    fn test_batch_result_allocation_deallocation() {
-        unsafe {
-            // Simulate the exact allocation pattern from kreuzberg_batch_extract_files_sync
-            let c_results = vec![
-                create_mock_extraction_result(),
-                create_mock_extraction_result(),
-                create_mock_extraction_result(),
-            ];
-
-            let actual_count = c_results.len();
-
-            // This is the exact pattern used in kreuzberg_batch_extract_files_sync
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: actual_count,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            // Verify the batch result is valid
-            assert!(!batch_result.is_null());
-            assert_eq!((*batch_result).count, 3);
-            assert!((*batch_result).success);
-
-            // Now free it using the public API
-            kreuzberg_free_batch_result(batch_result);
-
-            // If we got here without crashing, the allocation/deallocation pattern is correct
-        }
-    }
-
-    #[test]
-    fn test_free_null_batch() {
-        unsafe {
-            // Freeing NULL batch should not crash
-            kreuzberg_free_batch_result(ptr::null_mut());
-        }
-    }
-
-    #[test]
-    fn test_free_null_result() {
-        unsafe {
-            // Freeing NULL result should not crash
-            kreuzberg_free_result(ptr::null_mut());
-        }
-    }
-
-    #[test]
-    fn test_free_null_string() {
-        unsafe {
-            // Freeing NULL string should not crash
-            kreuzberg_free_string(ptr::null_mut());
-        }
-    }
-
-    #[test]
-    fn test_batch_result_with_empty_results() {
-        unsafe {
-            // Test batch result with zero results
-            let c_results: Vec<*mut CExtractionResult> = Vec::new();
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: 0,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            assert!(!batch_result.is_null());
-            assert_eq!((*batch_result).count, 0);
-
-            // Free should handle empty batch gracefully
-            kreuzberg_free_batch_result(batch_result);
-        }
-    }
-
-    #[test]
-    fn test_batch_result_with_null_elements() {
-        unsafe {
-            // Test batch result where some elements are NULL
-            let c_results = vec![
-                create_mock_extraction_result(),
-                ptr::null_mut(), // NULL element
-                create_mock_extraction_result(),
-            ];
-
-            let actual_count = c_results.len();
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: actual_count,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            // Free should handle NULL elements gracefully
-            kreuzberg_free_batch_result(batch_result);
-        }
-    }
-
-    #[test]
-    fn test_batch_result_single_element() {
-        unsafe {
-            // Test batch allocation/deallocation with exactly 1 result
-            // This is important for boundary condition testing
-            let c_results = vec![create_mock_extraction_result()];
-
-            let actual_count = c_results.len();
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: actual_count,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            // Verify the batch result is valid
-            assert!(!batch_result.is_null());
-            assert_eq!((*batch_result).count, 1);
-            assert!((*batch_result).success);
-
-            // Free should handle single-element batch correctly
-            kreuzberg_free_batch_result(batch_result);
-        }
-    }
-
-    #[test]
-    fn test_batch_result_large_size() {
-        unsafe {
-            // Test batch with 100 elements to catch boundary conditions
-            // This verifies the system can handle larger batches without memory corruption
-            let mut c_results = Vec::with_capacity(100);
-
-            for _ in 0..100 {
-                c_results.push(create_mock_extraction_result());
-            }
-
-            let actual_count = c_results.len();
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: actual_count,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            // Verify the batch result is valid
-            assert!(!batch_result.is_null());
-            assert_eq!((*batch_result).count, 100);
-            assert!((*batch_result).success);
-
-            // Free should handle large batch correctly without memory issues
-            kreuzberg_free_batch_result(batch_result);
-        }
-    }
-
-    #[test]
-    fn test_repeated_allocation_deallocation() {
-        unsafe {
-            // Stress test: 1000 iterations of allocation/deallocation
-            // This catches memory leaks, corruption, and use-after-free issues
-            for _ in 0..1000 {
-                let result = create_mock_extraction_result();
-
-                // Verify the result is valid
-                assert!(!result.is_null());
-                assert!((*result).success);
-
-                // Free the result
-                kreuzberg_free_result(result);
-            }
-
-            // If we got here without crashing or leaking, the memory management is sound
-        }
-    }
-
-    // ==================== Box/Vec Symmetry Test ====================
-
-    #[test]
-    fn test_box_vec_symmetry() {
-        unsafe {
-            // This test verifies the fix for the allocation/deallocation bug
-            // Create a Vec, convert to boxed slice, then verify correct deallocation
-
-            let mut vec = Vec::with_capacity(5);
-            vec.push(42u32);
-            vec.push(100u32);
-            vec.push(255u32);
-
-            let len = vec.len();
-
-            // Convert to boxed slice (this is what kreuzberg_batch_extract_files_sync does)
-            let boxed_slice = vec.into_boxed_slice();
-            let raw_ptr = Box::into_raw(boxed_slice) as *mut u32;
-
-            // Verify we can read the values
-            assert_eq!(*raw_ptr.add(0), 42);
-            assert_eq!(*raw_ptr.add(1), 100);
-            assert_eq!(*raw_ptr.add(2), 255);
-
-            // Now deallocate using the correct method (from kreuzberg_free_batch_result)
-            // IMPORTANT: Must use Box::from_raw with slice pointer, not Vec::from_raw_parts
-            let _boxed_slice = Box::from_raw(std::ptr::slice_from_raw_parts_mut(raw_ptr, len));
-
-            // If we got here without crashing, the symmetry is correct
-        }
-    }
-
-    #[test]
-    fn test_box_vec_symmetry_pointers() {
-        unsafe {
-            // Test with pointer types (as used in CBatchResult)
-            let vec: Vec<*mut CExtractionResult> = vec![
-                create_mock_extraction_result(),
-                create_mock_extraction_result(),
-                create_mock_extraction_result(),
-            ];
-
-            let len = vec.len();
-
-            // Convert to boxed slice
-            let boxed_slice = vec.into_boxed_slice();
-            let raw_ptr = Box::into_raw(boxed_slice) as *mut *mut CExtractionResult;
-
-            // Free individual results first
-            for i in 0..len {
-                let result_ptr = *raw_ptr.add(i);
-                if !result_ptr.is_null() {
-                    kreuzberg_free_result(result_ptr);
-                }
-            }
-
-            // Now free the array itself
-            let _boxed_slice = Box::from_raw(std::ptr::slice_from_raw_parts_mut(raw_ptr, len));
-
-            // If we got here without crashing, the symmetry is correct
-        }
-    }
-
-    // ==================== FFI Function Smoke Tests ====================
-
-    #[test]
-    fn test_version_not_null() {
-        unsafe {
-            let version = kreuzberg_version();
-            assert!(!version.is_null(), "Version string should not be NULL");
-
-            let version_str = CStr::from_ptr(version).to_str().unwrap();
-            assert!(!version_str.is_empty(), "Version string should not be empty");
-
-            // Verify it looks like a version string (has dots or numbers)
-            assert!(
-                version_str.contains('.') || version_str.chars().any(|c| c.is_numeric()),
-                "Version string should contain version info"
-            );
-        }
-    }
-
-    #[test]
-    fn test_null_config_handling() {
-        unsafe {
-            // Test that functions handle NULL config gracefully
-            // kreuzberg_batch_extract_files_sync with NULL config should use defaults
-
-            // Create a valid file paths array
-            let path1 = CString::new("/tmp/test1.txt").unwrap();
-            let path2 = CString::new("/tmp/test2.txt").unwrap();
-            let paths = [path1.as_ptr(), path2.as_ptr()];
-
-            // This should not crash with NULL config (though it may fail due to missing files)
-            let result = kreuzberg_batch_extract_files_sync(paths.as_ptr(), 2, ptr::null());
-
-            // Result might be NULL due to file not existing, but it shouldn't crash
-            if !result.is_null() {
-                kreuzberg_free_batch_result(result);
-            }
-        }
-    }
-
-    #[test]
-    fn test_extraction_result_free_with_null_fields() {
-        unsafe {
-            // Test freeing a result where most fields are NULL
-            let result = Box::into_raw(Box::new(CExtractionResult {
-                content: CString::new("content").unwrap().into_raw(),
-                mime_type: CString::new("text/plain").unwrap().into_raw(),
-                language: ptr::null_mut(),
-                date: ptr::null_mut(),
-                subject: ptr::null_mut(),
-                tables_json: ptr::null_mut(),
-                detected_languages_json: ptr::null_mut(),
-                metadata_json: ptr::null_mut(),
-                chunks_json: ptr::null_mut(),
-                images_json: ptr::null_mut(),
-                page_structure_json: ptr::null_mut(),
-                pages_json: ptr::null_mut(),
-                success: true,
-                _padding1: [0u8; 7],
-            }));
-
-            // Should not crash when freeing result with NULL fields
-            kreuzberg_free_result(result);
-        }
-    }
-
-    #[test]
-    fn test_extraction_result_free_all_fields_allocated() {
-        unsafe {
-            // Test freeing a result where ALL 12 string fields are allocated
-            // This verifies that kreuzberg_free_result properly frees all fields
-            let result = Box::into_raw(Box::new(CExtractionResult {
-                content: CString::new("test content").unwrap().into_raw(),
-                mime_type: CString::new("application/pdf").unwrap().into_raw(),
-                language: CString::new("en").unwrap().into_raw(),
-                date: CString::new("2024-01-01").unwrap().into_raw(),
-                subject: CString::new("Test Subject").unwrap().into_raw(),
-                tables_json: CString::new("[]").unwrap().into_raw(),
-                detected_languages_json: CString::new("[\"en\"]").unwrap().into_raw(),
-                metadata_json: CString::new("{}").unwrap().into_raw(),
-                chunks_json: CString::new("[{\"text\":\"chunk1\"}]").unwrap().into_raw(),
-                images_json: CString::new("[{\"data\":\"base64\"}]").unwrap().into_raw(),
-                page_structure_json: CString::new("{\"pages\":1}").unwrap().into_raw(),
-                pages_json: CString::new("[{\"page\":1,\"content\":\"test\"}]").unwrap().into_raw(),
-                success: true,
-                _padding1: [0u8; 7],
-            }));
-
-            // Should properly free all 12 allocated string fields without leaking memory
-            kreuzberg_free_result(result);
-        }
-    }
-
-    #[test]
-    fn test_string_allocation_deallocation() {
-        unsafe {
-            // Test string cloning and freeing
-            let original = CString::new("test string").unwrap();
-            let cloned = kreuzberg_clone_string(original.as_ptr());
-
-            assert!(!cloned.is_null(), "Cloned string should not be NULL");
-
-            let cloned_str = CStr::from_ptr(cloned).to_str().unwrap();
-            assert_eq!(cloned_str, "test string", "Cloned string should match original");
-
-            // Free the cloned string
-            kreuzberg_free_string(cloned);
-        }
-    }
-
-    #[test]
-    fn test_clone_null_string() {
-        unsafe {
-            // Cloning NULL should return NULL and set error
-            clear_last_error();
-            let cloned = kreuzberg_clone_string(ptr::null());
-
-            assert!(cloned.is_null(), "Cloning NULL should return NULL");
-
-            let error = kreuzberg_last_error();
-            assert!(!error.is_null(), "Error should be set");
-            let error_str = CStr::from_ptr(error).to_str().unwrap();
-            assert!(error_str.contains("NULL"), "Error should mention NULL");
-        }
-    }
-
-    #[test]
-    fn test_batch_result_success_field() {
-        unsafe {
-            // Test that success field is properly set
-            let c_results: Vec<*mut CExtractionResult> = Vec::new();
-            let results_array = c_results.into_boxed_slice();
-            let results_ptr = Box::into_raw(results_array) as *mut *mut CExtractionResult;
-
-            let batch_result = Box::into_raw(Box::new(CBatchResult {
-                results: results_ptr,
-                count: 0,
-                success: true,
-                _padding2: [0u8; 7],
-            }));
-
-            assert!((*batch_result).success, "Success field should be true");
-
-            kreuzberg_free_batch_result(batch_result);
-        }
-    }
-
-    #[test]
-    fn test_last_error_cleared() {
-        unsafe {
-            // Test that clear_last_error works
-            set_last_error("test error".to_string());
-
-            let error = kreuzberg_last_error();
-            assert!(!error.is_null());
-
-            clear_last_error();
-
-            let error_after = kreuzberg_last_error();
-            assert!(error_after.is_null(), "Error should be cleared");
-        }
-    }
-
-    // ==================== Additional Safety Net Tests (PR #1) ====================
-
-    /// Test CExtractionResult size exactly matches FFI contract
-    #[test]
-    fn test_c_extraction_result_size() {
-        assert_eq!(std::mem::size_of::<CExtractionResult>(), 104);
-        assert_eq!(std::mem::align_of::<CExtractionResult>(), 8);
-    }
-
-    /// Test CBatchResult size exactly matches FFI contract
-    #[test]
-    fn test_c_batch_result_size() {
-        assert_eq!(std::mem::size_of::<CBatchResult>(), 24);
-        assert_eq!(std::mem::align_of::<CBatchResult>(), 8);
-    }
-
-    /// Test CBytesWithMime size exactly matches FFI contract
-    #[test]
-    fn test_c_bytes_with_mime_size() {
-        assert_eq!(std::mem::size_of::<CBytesWithMime>(), 24);
-        assert_eq!(std::mem::align_of::<CBytesWithMime>(), 8);
-    }
-
-    /// Test that kreuzberg_extract_bytes_sync handles NULL data pointer
-    #[test]
-    fn test_extract_bytes_null_data() {
-        unsafe {
-            let mime = CString::new("text/plain").unwrap();
-            let result = kreuzberg_extract_bytes_sync(ptr::null(), 0, mime.as_ptr());
-            assert!(result.is_null(), "Should return NULL for NULL data pointer");
-        }
-    }
-
-    /// Test that kreuzberg_extract_bytes_sync handles NULL mime type
-    #[test]
-    fn test_extract_bytes_null_mime() {
-        unsafe {
-            let data = b"test data";
-            let result = kreuzberg_extract_bytes_sync(data.as_ptr(), data.len(), ptr::null());
-            assert!(result.is_null(), "Should return NULL for NULL mime type");
-        }
-    }
-
-    /// Test that kreuzberg_batch_extract_files_sync handles NULL paths pointer
-    #[test]
-    fn test_batch_extract_null_paths() {
-        unsafe {
-            let result = kreuzberg_batch_extract_files_sync(ptr::null(), 0, ptr::null());
-            assert!(result.is_null(), "Should return NULL for NULL paths pointer");
-        }
-    }
-
-    /// Test that kreuzberg_batch_extract_bytes_sync handles NULL bytes pointer
-    #[test]
-    fn test_batch_extract_bytes_null() {
-        unsafe {
-            let result = kreuzberg_batch_extract_bytes_sync(ptr::null(), 0, ptr::null());
-            assert!(result.is_null(), "Should return NULL for NULL bytes pointer");
-        }
-    }
-
-    /// Test that kreuzberg_register_ocr_backend handles NULL name
-    #[test]
-    fn test_register_ocr_backend_null_name() {
-        unsafe {
-            extern "C" fn dummy_callback(_: *const u8, _: usize, _: *const c_char) -> *mut c_char {
-                ptr::null_mut()
-            }
-            let result = kreuzberg_register_ocr_backend(ptr::null(), dummy_callback);
-            assert!(!result, "Should return false for NULL backend name");
-        }
-    }
-
-    /// Test that kreuzberg_unregister_ocr_backend handles NULL name
-    #[test]
-    fn test_unregister_ocr_backend_null_name() {
-        unsafe {
-            let result = kreuzberg_unregister_ocr_backend(ptr::null());
-            assert!(!result, "Should return false for NULL backend name");
-        }
-    }
-
-    /// Test that kreuzberg_register_post_processor handles NULL name
-    #[test]
-    fn test_register_post_processor_null_name() {
-        unsafe {
-            extern "C" fn dummy_callback(_: *const c_char) -> *mut c_char {
-                ptr::null_mut()
-            }
-            let result = kreuzberg_register_post_processor(ptr::null(), dummy_callback, 0);
-            assert!(!result, "Should return false for NULL processor name");
-        }
-    }
-
-    /// Test that kreuzberg_unregister_post_processor handles NULL name
-    #[test]
-    fn test_unregister_post_processor_null_name() {
-        unsafe {
-            let result = kreuzberg_unregister_post_processor(ptr::null());
-            assert!(!result, "Should return false for NULL processor name");
-        }
-    }
-
-    /// Test that kreuzberg_register_validator handles NULL name
-    #[test]
-    fn test_register_validator_null_name() {
-        unsafe {
-            extern "C" fn dummy_callback(_: *const c_char) -> *mut c_char {
-                ptr::null_mut()
-            }
-            let result = kreuzberg_register_validator(ptr::null(), dummy_callback, 0);
-            assert!(!result, "Should return false for NULL validator name");
-        }
-    }
-
-    /// Test that kreuzberg_unregister_validator handles NULL name
-    #[test]
-    fn test_unregister_validator_null_name() {
-        unsafe {
-            let result = kreuzberg_unregister_validator(ptr::null());
-            assert!(!result, "Should return false for NULL validator name");
-        }
-    }
-
-    /// Test that kreuzberg_get_ocr_languages handles NULL backend
-    #[test]
-    fn test_get_ocr_languages_null_backend() {
-        unsafe {
-            let result = kreuzberg_get_ocr_languages(ptr::null());
-            assert!(result.is_null(), "Should return NULL for NULL backend name");
-        }
-    }
-
-    /// Test that kreuzberg_is_language_supported handles NULL backend
-    #[test]
-    fn test_is_language_supported_null_backend() {
-        unsafe {
-            let lang = CString::new("en").unwrap();
-            let result = kreuzberg_is_language_supported(ptr::null(), lang.as_ptr());
-            assert_eq!(result, 0, "Should return 0 (false) for NULL backend");
-        }
-    }
-
-    /// Test that kreuzberg_is_language_supported handles NULL language
-    #[test]
-    fn test_is_language_supported_null_language() {
-        unsafe {
-            let backend = CString::new("tesseract").unwrap();
-            let result = kreuzberg_is_language_supported(backend.as_ptr(), ptr::null());
-            assert_eq!(result, 0, "Should return 0 (false) for NULL language");
-        }
-    }
-
-    /// Test that kreuzberg_validate_binarization_method handles NULL
-    #[test]
-    fn test_validate_binarization_method_null() {
-        unsafe {
-            let result = kreuzberg_validate_binarization_method(ptr::null());
-            assert_eq!(result, 0, "Should return 0 (invalid) for NULL method");
-        }
-    }
-
-    /// Test that kreuzberg_validate_token_reduction_level handles NULL
-    #[test]
-    fn test_validate_token_reduction_level_null() {
-        unsafe {
-            let result = kreuzberg_validate_token_reduction_level(ptr::null());
-            assert_eq!(result, 0, "Should return 0 (invalid) for NULL level");
-        }
-    }
-
-    /// Test that kreuzberg_validate_ocr_backend handles NULL
-    #[test]
-    fn test_validate_ocr_backend_null() {
-        unsafe {
-            let result = kreuzberg_validate_ocr_backend(ptr::null());
-            assert_eq!(result, 0, "Should return 0 (invalid) for NULL backend");
-        }
-    }
-
-    /// Test that kreuzberg_validate_language_code handles NULL
-    #[test]
-    fn test_validate_language_code_null() {
-        unsafe {
-            let result = kreuzberg_validate_language_code(ptr::null());
-            assert_eq!(result, 0, "Should return 0 (invalid) for NULL language code");
-        }
-    }
-
-    /// Test that kreuzberg_validate_output_format handles NULL
-    #[test]
-    fn test_validate_output_format_null() {
-        unsafe {
-            let result = kreuzberg_validate_output_format(ptr::null());
-            assert_eq!(result, 0, "Should return 0 (invalid) for NULL format");
-        }
-    }
-
-    /// Test that kreuzberg_version returns non-null
-    #[test]
-    fn test_version_returns_non_null() {
-        unsafe {
-            let version = kreuzberg_version();
-            assert!(!version.is_null(), "kreuzberg_version should never return NULL");
-            let version_str = CStr::from_ptr(version).to_str().unwrap();
-            assert!(!version_str.is_empty(), "Version string should not be empty");
-        }
-    }
-
-    /// Test that kreuzberg_last_error returns NULL when no error
-    #[test]
-    fn test_last_error_null_when_no_error() {
-        unsafe {
-            clear_last_error();
-            let error = kreuzberg_last_error();
-            assert!(error.is_null(), "Should return NULL when no error is set");
-        }
-    }
-
-    /// Test that kreuzberg_clone_string returns non-null for valid input
-    #[test]
-    fn test_clone_string_returns_non_null() {
-        unsafe {
-            let input = CString::new("test").unwrap();
-            let cloned = kreuzberg_clone_string(input.as_ptr());
-            assert!(!cloned.is_null(), "Clone should return non-NULL for valid input");
-            kreuzberg_free_string(cloned);
-        }
-    }
-
-    /// Test clearing OCR backends doesn't crash
-    #[test]
-    fn test_clear_ocr_backends_doesnt_crash() {
-        unsafe {
-            // This should not crash even if called multiple times
-            kreuzberg_clear_ocr_backends();
-            kreuzberg_clear_ocr_backends();
-        }
-    }
-
-    /// Test clearing post processors doesn't crash
-    #[test]
-    fn test_clear_post_processors_doesnt_crash() {
-        unsafe {
-            // This should not crash even if called multiple times
-            kreuzberg_clear_post_processors();
-            kreuzberg_clear_post_processors();
-        }
-    }
-
-    /// Test clearing validators doesn't crash
-    #[test]
-    fn test_clear_validators_doesnt_crash() {
-        unsafe {
-            // This should not crash even if called multiple times
-            kreuzberg_clear_validators();
-            kreuzberg_clear_validators();
-        }
-    }
-
-    /// Test clearing document extractors doesn't crash
-    #[test]
-    fn test_clear_document_extractors_doesnt_crash() {
-        unsafe {
-            // This should not crash even if called multiple times
-            kreuzberg_clear_document_extractors();
-            kreuzberg_clear_document_extractors();
-        }
-    }
-
-    /// Test that list functions return non-null JSON arrays
-    #[test]
-    fn test_list_functions_return_non_null() {
-        unsafe {
-            // All list functions should return non-NULL JSON arrays (even if empty)
-            let ocr = kreuzberg_list_ocr_backends();
-            assert!(!ocr.is_null(), "list_ocr_backends should return non-NULL");
-            kreuzberg_free_string(ocr);
-
-            let processors = kreuzberg_list_post_processors();
-            assert!(!processors.is_null(), "list_post_processors should return non-NULL");
-            kreuzberg_free_string(processors);
-
-            let validators = kreuzberg_list_validators();
-            assert!(!validators.is_null(), "list_validators should return non-NULL");
-            kreuzberg_free_string(validators);
-
-            let extractors = kreuzberg_list_document_extractors();
-            assert!(!extractors.is_null(), "list_document_extractors should return non-NULL");
-            kreuzberg_free_string(extractors);
-
-            let backends_with_langs = kreuzberg_list_ocr_backends_with_languages();
-            assert!(
-                !backends_with_langs.is_null(),
-                "list_ocr_backends_with_languages should return non-NULL"
-            );
-            kreuzberg_free_string(backends_with_langs);
-        }
-    }
-
-    /// Test numeric validation functions with edge cases
-    #[test]
-    fn test_numeric_validation_edge_cases() {
-        // Test Tesseract PSM validation with invalid values
-        assert_eq!(
-            kreuzberg_validate_tesseract_psm(-1),
-            0,
-            "Negative PSM should be invalid"
-        );
-        assert_eq!(kreuzberg_validate_tesseract_psm(0), 1, "PSM 0 should be valid");
-        assert_eq!(kreuzberg_validate_tesseract_psm(13), 1, "PSM 13 should be valid");
-        assert_eq!(kreuzberg_validate_tesseract_psm(14), 0, "PSM 14 should be invalid");
-
-        // Test Tesseract OEM validation
-        assert_eq!(
-            kreuzberg_validate_tesseract_oem(-1),
-            0,
-            "Negative OEM should be invalid"
-        );
-        assert_eq!(kreuzberg_validate_tesseract_oem(0), 1, "OEM 0 should be valid");
-        assert_eq!(kreuzberg_validate_tesseract_oem(3), 1, "OEM 3 should be valid");
-        assert_eq!(kreuzberg_validate_tesseract_oem(4), 0, "OEM 4 should be invalid");
-
-        // Test confidence validation
-        assert_eq!(
-            kreuzberg_validate_confidence(-0.1),
-            0,
-            "Negative confidence should be invalid"
-        );
-        assert_eq!(kreuzberg_validate_confidence(0.0), 1, "0.0 confidence should be valid");
-        assert_eq!(kreuzberg_validate_confidence(0.5), 1, "0.5 confidence should be valid");
-        assert_eq!(kreuzberg_validate_confidence(1.0), 1, "1.0 confidence should be valid");
-        assert_eq!(
-            kreuzberg_validate_confidence(1.1),
-            0,
-            "1.1 confidence should be invalid"
-        );
-
-        // Test DPI validation
-        assert_eq!(kreuzberg_validate_dpi(0), 0, "0 DPI should be invalid");
-        assert_eq!(kreuzberg_validate_dpi(-1), 0, "-1 DPI should be invalid");
-        assert_eq!(kreuzberg_validate_dpi(1), 1, "1 DPI should be valid");
-        assert_eq!(kreuzberg_validate_dpi(72), 1, "72 DPI should be valid");
-        assert_eq!(kreuzberg_validate_dpi(300), 1, "300 DPI should be valid");
-        assert_eq!(kreuzberg_validate_dpi(2400), 1, "2400 DPI should be valid");
-        assert_eq!(kreuzberg_validate_dpi(2401), 0, "2401 DPI should be invalid");
-
-        // Test chunking params validation
-        assert_eq!(
-            kreuzberg_validate_chunking_params(0, 0),
-            0,
-            "0 max_chars should be invalid"
-        );
-        assert_eq!(
-            kreuzberg_validate_chunking_params(100, 0),
-            1,
-            "Valid params should pass"
-        );
-        assert_eq!(
-            kreuzberg_validate_chunking_params(100, 50),
-            1,
-            "Valid overlap should pass"
-        );
-        assert_eq!(
-            kreuzberg_validate_chunking_params(100, 100),
-            0,
-            "Overlap >= max_chars should be invalid"
-        );
-        assert_eq!(
-            kreuzberg_validate_chunking_params(100, 101),
-            0,
-            "Overlap > max_chars should be invalid"
-        );
-    }
-}