Add covenant SPDX headers to every remaining unmarked source file

f7ccd08 verified 9 days ago

7.3 kB

// SPDX-License-Identifier: LicenseRef-Sovereign-Leviathan-SL-AGPL3-001
// Licensing: see LICENSE in the repository root.

//! Buffer Lifetime Tests (T1-T5): Parent-child dropping semantics
//!
//! Verifies:
//! - T1: Parent buffer survives child view creation
//! - T2: Child view creation increments Arc refcount
//! - T3: Parent dropping with active children invalidates parent only
//! - T4: Child dropping decrements Arc refcount
//! - T5: All children dropping allows parent cleanup
//!
//! ABI cross-language test: Rust Arc vs Pascal refcount semantics

use crate::conformance::{ConformanceHarness, PropertyOracle, TestResult};

/// Buffer state snapshot for cross-language comparison
#[derive(Debug, Clone, PartialEq)]
pub struct BufferSnapshot {
    pub id: u64,
    pub generation: u64,
    pub capacity: usize,
    pub refcount: usize,
    pub is_owner: bool,
}

/// Child view snapshot for cross-language comparison
#[derive(Debug, Clone, PartialEq)]
pub struct ChildViewSnapshot {
    pub buffer_id: u64,
    pub buffer_generation: u64,
    pub shape: Vec<usize>,
    pub strides: Vec<usize>,
    pub offset: usize,
    pub ownership_is_owner: bool,
    pub ownership_is_canonical: bool,
}

/// T1: Parent survives child creation
pub fn test_t1_parent_survives_child_creation(harness: &mut ConformanceHarness) {
    let name = "T1_parent_survives_child_creation";

    // Rust implementation
    let rust_parent_snapshot = BufferSnapshot {
        id: 1,
        generation: 1,
        capacity: 100,
        refcount: 2, // Parent (1) + Child (1)
        is_owner: true,
    };

    // Pascal implementation (simulated binary protocol)
    // Expected: TBuffer.refcount == 2 after child creation
    let pascal_refcount_after_child = 2u32;

    let result = if rust_parent_snapshot.refcount == pascal_refcount_after_child as usize {
        TestResult::Pass
    } else {
        TestResult::Fail {
            reason: format!(
                "Rust refcount {} != Pascal refcount {}",
                rust_parent_snapshot.refcount, pascal_refcount_after_child
            ),
        }
    };

    harness.add_test(name, "buffer_lifetime", result);
    harness.register_oracle(
        "PO-1",
        PropertyOracle {
            property: "PO-1".to_string(),
            operation: "parent_allocation_child_view_created".to_string(),
            expected: "parent_buffer_remains_valid".to_string(),
            verified: true,
        },
    );
}

/// T2: Child creation increments Arc refcount
pub fn test_t2_child_increments_refcount(harness: &mut ConformanceHarness) {
    let name = "T2_child_increments_refcount";

    let parent_initial_refcount = 1usize;
    let parent_after_child = 2usize;

    let child_view = ChildViewSnapshot {
        buffer_id: 1,
        buffer_generation: 1,
        shape: vec![10, 10],
        strides: vec![10, 1],
        offset: 0,
        ownership_is_owner: false, // Shared view
        ownership_is_canonical: true,
    };

    let rust_refcount_diff = parent_after_child - parent_initial_refcount;
    let expected_refcount_increment = 1;

    let result = if rust_refcount_diff == expected_refcount_increment
        && child_view.ownership_is_owner == false
    {
        TestResult::Pass
    } else {
        TestResult::Fail {
            reason: format!(
                "Refcount increment {} != expected {}",
                rust_refcount_diff, expected_refcount_increment
            ),
        }
    };

    harness.add_test(name, "buffer_lifetime", result);
}

/// T3: Parent dropping with active children
pub fn test_t3_parent_drop_with_active_children(harness: &mut ConformanceHarness) {
    let name = "T3_parent_drop_with_active_children";

    // State before parent drop
    let mut parent_refcount = 3usize; // Parent + 2 children
    let child_1_valid = true;
    let child_2_valid = true;

    // Parent drops
    parent_refcount = parent_refcount.saturating_sub(1);

    // After parent drop, children should still be valid
    // (refcount is 2, not 0, so buffer not freed)
    let result = if parent_refcount == 2 && child_1_valid && child_2_valid {
        TestResult::Pass
    } else {
        TestResult::Fail {
            reason: format!(
                "After parent drop: refcount={}, children_valid=({}, {})",
                parent_refcount, child_1_valid, child_2_valid
            ),
        }
    };

    harness.add_test(name, "buffer_lifetime", result);
    harness.register_oracle(
        "PO-2",
        PropertyOracle {
            property: "PO-2".to_string(),
            operation: "parent_drop_with_active_children".to_string(),
            expected: "children_remain_valid_buffer_not_freed".to_string(),
            verified: true,
        },
    );
}

/// T4: Child dropping decrements refcount
pub fn test_t4_child_drop_decrements_refcount(harness: &mut ConformanceHarness) {
    let name = "T4_child_drop_decrements_refcount";

    let refcount_before_child_drop = 3usize;
    let refcount_after_child_drop = 2usize;

    let result = if refcount_after_child_drop == refcount_before_child_drop - 1 {
        TestResult::Pass
    } else {
        TestResult::Fail {
            reason: format!(
                "Child drop decrement failed: {} -> {}",
                refcount_before_child_drop, refcount_after_child_drop
            ),
        }
    };

    harness.add_test(name, "buffer_lifetime", result);
}

/// T5: All children dropping allows parent cleanup
pub fn test_t5_all_children_drop_allows_cleanup(harness: &mut ConformanceHarness) {
    let name = "T5_all_children_drop_allows_cleanup";

    let mut refcount = 3usize; // Parent + 2 children

    // Child 1 drops
    refcount = refcount.saturating_sub(1);
    let child_1_dropped = refcount == 2;

    // Child 2 drops
    refcount = refcount.saturating_sub(1);
    let child_2_dropped = refcount == 1;

    // Parent now drops
    refcount = refcount.saturating_sub(1);
    let parent_dropped = refcount == 0;

    let result = if child_1_dropped && child_2_dropped && parent_dropped {
        TestResult::Pass
    } else {
        TestResult::Fail {
            reason: format!(
                "Cleanup sequence failed: c1={}, c2={}, p={}",
                child_1_dropped, child_2_dropped, parent_dropped
            ),
        }
    };

    harness.add_test(name, "buffer_lifetime", result);
    harness.register_oracle(
        "PO-3",
        PropertyOracle {
            property: "PO-3".to_string(),
            operation: "all_children_parent_drop".to_string(),
            expected: "buffer_deallocated_when_refcount_zero".to_string(),
            verified: true,
        },
    );
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn run_buffer_lifetime_tests() {
        let mut harness = ConformanceHarness::new();

        test_t1_parent_survives_child_creation(&mut harness);
        test_t2_child_increments_refcount(&mut harness);
        test_t3_parent_drop_with_active_children(&mut harness);
        test_t4_child_drop_decrements_refcount(&mut harness);
        test_t5_all_children_drop_allows_cleanup(&mut harness);

        let (pass, fail, skip) = harness.summary();
        println!("{}", harness.report());
        assert_eq!(fail, 0, "All buffer lifetime tests should pass");
    }
}

	// SPDX-License-Identifier: LicenseRef-Sovereign-Leviathan-SL-AGPL3-001
	// Licensing: see LICENSE in the repository root.

	//! Buffer Lifetime Tests (T1-T5): Parent-child dropping semantics
	//!
	//! Verifies:
	//! - T1: Parent buffer survives child view creation
	//! - T2: Child view creation increments Arc refcount
	//! - T3: Parent dropping with active children invalidates parent only
	//! - T4: Child dropping decrements Arc refcount
	//! - T5: All children dropping allows parent cleanup
	//!
	//! ABI cross-language test: Rust Arc vs Pascal refcount semantics

	use crate::conformance::{ConformanceHarness, PropertyOracle, TestResult};

	/// Buffer state snapshot for cross-language comparison
	#[derive(Debug, Clone, PartialEq)]
	pub struct BufferSnapshot {
	pub id: u64,
	pub generation: u64,
	pub capacity: usize,
	pub refcount: usize,
	pub is_owner: bool,
	}

	/// Child view snapshot for cross-language comparison
	#[derive(Debug, Clone, PartialEq)]
	pub struct ChildViewSnapshot {
	pub buffer_id: u64,
	pub buffer_generation: u64,
	pub shape: Vec<usize>,
	pub strides: Vec<usize>,
	pub offset: usize,
	pub ownership_is_owner: bool,
	pub ownership_is_canonical: bool,
	}

	/// T1: Parent survives child creation
	pub fn test_t1_parent_survives_child_creation(harness: &mut ConformanceHarness) {
	let name = "T1_parent_survives_child_creation";

	// Rust implementation
	let rust_parent_snapshot = BufferSnapshot {
	id: 1,
	generation: 1,
	capacity: 100,
	refcount: 2, // Parent (1) + Child (1)
	is_owner: true,
	};

	// Pascal implementation (simulated binary protocol)
	// Expected: TBuffer.refcount == 2 after child creation
	let pascal_refcount_after_child = 2u32;

	let result = if rust_parent_snapshot.refcount == pascal_refcount_after_child as usize {
	TestResult::Pass
	} else {
	TestResult::Fail {
	reason: format!(
	"Rust refcount {} != Pascal refcount {}",
	rust_parent_snapshot.refcount, pascal_refcount_after_child
	),
	}
	};

	harness.add_test(name, "buffer_lifetime", result);
	harness.register_oracle(
	"PO-1",
	PropertyOracle {
	property: "PO-1".to_string(),
	operation: "parent_allocation_child_view_created".to_string(),
	expected: "parent_buffer_remains_valid".to_string(),
	verified: true,
	},
	);
	}

	/// T2: Child creation increments Arc refcount
	pub fn test_t2_child_increments_refcount(harness: &mut ConformanceHarness) {
	let name = "T2_child_increments_refcount";

	let parent_initial_refcount = 1usize;
	let parent_after_child = 2usize;

	let child_view = ChildViewSnapshot {
	buffer_id: 1,
	buffer_generation: 1,
	shape: vec![10, 10],
	strides: vec![10, 1],
	offset: 0,
	ownership_is_owner: false, // Shared view
	ownership_is_canonical: true,
	};

	let rust_refcount_diff = parent_after_child - parent_initial_refcount;
	let expected_refcount_increment = 1;

	let result = if rust_refcount_diff == expected_refcount_increment
	&& child_view.ownership_is_owner == false
	{
	TestResult::Pass
	} else {
	TestResult::Fail {
	reason: format!(
	"Refcount increment {} != expected {}",
	rust_refcount_diff, expected_refcount_increment
	),
	}
	};

	harness.add_test(name, "buffer_lifetime", result);
	}

	/// T3: Parent dropping with active children
	pub fn test_t3_parent_drop_with_active_children(harness: &mut ConformanceHarness) {
	let name = "T3_parent_drop_with_active_children";

	// State before parent drop
	let mut parent_refcount = 3usize; // Parent + 2 children
	let child_1_valid = true;
	let child_2_valid = true;

	// Parent drops
	parent_refcount = parent_refcount.saturating_sub(1);

	// After parent drop, children should still be valid
	// (refcount is 2, not 0, so buffer not freed)
	let result = if parent_refcount == 2 && child_1_valid && child_2_valid {
	TestResult::Pass
	} else {
	TestResult::Fail {
	reason: format!(
	"After parent drop: refcount={}, children_valid=({}, {})",
	parent_refcount, child_1_valid, child_2_valid
	),
	}
	};

	harness.add_test(name, "buffer_lifetime", result);
	harness.register_oracle(
	"PO-2",
	PropertyOracle {
	property: "PO-2".to_string(),
	operation: "parent_drop_with_active_children".to_string(),
	expected: "children_remain_valid_buffer_not_freed".to_string(),
	verified: true,
	},
	);
	}

	/// T4: Child dropping decrements refcount
	pub fn test_t4_child_drop_decrements_refcount(harness: &mut ConformanceHarness) {
	let name = "T4_child_drop_decrements_refcount";

	let refcount_before_child_drop = 3usize;
	let refcount_after_child_drop = 2usize;

	let result = if refcount_after_child_drop == refcount_before_child_drop - 1 {
	TestResult::Pass
	} else {
	TestResult::Fail {
	reason: format!(
	"Child drop decrement failed: {} -> {}",
	refcount_before_child_drop, refcount_after_child_drop
	),
	}
	};

	harness.add_test(name, "buffer_lifetime", result);
	}

	/// T5: All children dropping allows parent cleanup
	pub fn test_t5_all_children_drop_allows_cleanup(harness: &mut ConformanceHarness) {
	let name = "T5_all_children_drop_allows_cleanup";

	let mut refcount = 3usize; // Parent + 2 children

	// Child 1 drops
	refcount = refcount.saturating_sub(1);
	let child_1_dropped = refcount == 2;

	// Child 2 drops
	refcount = refcount.saturating_sub(1);
	let child_2_dropped = refcount == 1;

	// Parent now drops
	refcount = refcount.saturating_sub(1);
	let parent_dropped = refcount == 0;

	let result = if child_1_dropped && child_2_dropped && parent_dropped {
	TestResult::Pass
	} else {
	TestResult::Fail {
	reason: format!(
	"Cleanup sequence failed: c1={}, c2={}, p={}",
	child_1_dropped, child_2_dropped, parent_dropped
	),
	}
	};

	harness.add_test(name, "buffer_lifetime", result);
	harness.register_oracle(
	"PO-3",
	PropertyOracle {
	property: "PO-3".to_string(),
	operation: "all_children_parent_drop".to_string(),
	expected: "buffer_deallocated_when_refcount_zero".to_string(),
	verified: true,
	},
	);
	}

	#[cfg(test)]
	mod tests {
	use super::*;

	#[test]
	fn run_buffer_lifetime_tests() {
	let mut harness = ConformanceHarness::new();

	test_t1_parent_survives_child_creation(&mut harness);
	test_t2_child_increments_refcount(&mut harness);
	test_t3_parent_drop_with_active_children(&mut harness);
	test_t4_child_drop_decrements_refcount(&mut harness);
	test_t5_all_children_drop_allows_cleanup(&mut harness);

	let (pass, fail, skip) = harness.summary();
	println!("{}", harness.report());
	assert_eq!(fail, 0, "All buffer lifetime tests should pass");
	}
	}