json-extractor 0.1.0

//! Integration tests for deeply nested structures
//!
//! These tests verify that the scanner can handle arbitrary nesting depths
//! without stack overflow or performance degradation.

use json_extractor::JsonFragmentScanner;

fn generate_nested_objects(depth: usize) -> String {
    let mut json = String::new();
    for i in 0..depth {
        json.push('{');
        json.push_str(&format!(r#""level_{}":"#, i));
    }
    json.push_str(r#"{"value": 123}"#);
    for _ in 0..depth {
        json.push('}');
    }
    json
}

fn generate_nested_arrays(depth: usize) -> String {
    let mut json = String::from("[");
    for _ in 1..depth {
        json.push('[');
    }
    json.push_str("123");
    for _ in 0..depth {
        json.push(']');
    }
    json
}

fn generate_mixed_nesting(depth: usize) -> String {
    let mut json = String::new();
    for i in 0..depth {
        if i % 2 == 0 {
            json.push('{');
            json.push_str(&format!(r#""key_{}":"#, i));
        } else {
            json.push('[');
        }
    }
    json.push_str("42");
    for i in (0..depth).rev() {
        if i % 2 == 0 {
            json.push('}');
        } else {
            json.push(']');
        }
    }
    json
}

#[test]
fn test_deep_nesting_50_levels() {
    let json = generate_nested_objects(50);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_deep_nesting_100_levels() {
    let json = generate_nested_objects(100);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_deep_nesting_200_levels() {
    // Test even deeper nesting
    let json = generate_nested_objects(200);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_deep_array_nesting_100_levels() {
    let json = generate_nested_arrays(100);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_mixed_nesting_100_levels() {
    let json = generate_mixed_nesting(100);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_deep_nesting_with_chunk_boundaries() {
    // Test that deeply nested JSON works correctly even when document size
    // crosses multiple SIMD chunk boundaries (64 bytes for AVX2)
    // Generate a document large enough to span multiple chunks
    let json = generate_nested_objects(80);

    // Verify the document is large enough to test multi-chunk processing
    assert!(
        json.len() > 128,
        "Document should be larger than 2 AVX2 chunks (128 bytes)"
    );

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1, "Should find exactly one fragment");
    assert!(
        fragments[0].is_complete(),
        "Deeply nested fragment should be complete"
    );
}

#[test]
fn test_deep_nesting_multiple_fragments() {
    // Multiple deeply nested fragments
    let mut data = String::new();
    for _ in 0..10 {
        data.push_str(&generate_nested_objects(50));
        data.push(' ');
    }

    let fragments = JsonFragmentScanner::scan_fragments(data.as_bytes());

    assert_eq!(fragments.len(), 10);
    for frag in fragments {
        assert!(frag.is_complete());
    }
}

#[test]
fn test_deep_nesting_error_recovery() {
    // Create a deeply nested fragment with an error, followed by a valid fragment
    let mut bad_json = String::from("{");
    for i in 0..50 {
        bad_json.push_str(&format!(r#""level_{}":{{"#, i));
    }
    bad_json.push_str("!!!"); // Invalid value
    bad_json.push(' ');
    bad_json.push_str(&generate_nested_objects(30));

    let fragments = JsonFragmentScanner::scan_fragments(bad_json.as_bytes());

    // Should get the incomplete fragment and the valid one
    assert_eq!(fragments.len(), 2);
    assert!(!fragments[0].is_complete());
    assert!(fragments[1].is_complete());
}

#[test]
fn test_deep_nesting_with_values_at_each_level() {
    // Deeply nested structure - verifies deep nesting works
    let json = generate_nested_objects(60);

    let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

    assert_eq!(fragments.len(), 1);
    assert!(fragments[0].is_complete());
}

#[test]
fn test_smallvec_stack_to_heap_transition() {
    // SmallVec uses stack for up to 8 levels, then heap
    // Test that transition works correctly by testing depths around that boundary

    for depth in [5, 8, 9, 15, 20] {
        let json = generate_nested_objects(depth);

        let fragments = JsonFragmentScanner::scan_fragments(json.as_bytes());

        assert_eq!(
            fragments.len(),
            1,
            "Failed at depth {}: expected 1 fragment",
            depth
        );
        assert!(
            fragments[0].is_complete(),
            "Failed at depth {}: fragment not complete",
            depth
        );
    }
}