set_theory 1.0.0

//! # CustomSet Unit Tests
//!
//! Comprehensive test suite for the `CustomSet` data structure.
//!
//! This module tests all core functionality of the `CustomSet` implementation,
//! including creation, membership, cardinality, subset operations, and
//! basic set operations.
//!
//! ## Test Coverage
//!
//! - **Creation**: Empty sets, from iterators, from predicates
//! - **Membership**: Contains, add, remove operations
//! - **Cardinality**: Size calculations
//! - **Subsets**: Subset, proper subset, superset relations
//! - **Equality**: Set equality and equivalence
//! - **Operations**: Union, intersection, difference, complement
//! - **Edge Cases**: Empty sets, nested sets, large sets
//!
//! ## Running Tests
//!
//! ```bash
//! # Run all CustomSet tests
//! cargo test custom_set_tests
//!
//! # Run specific test group
//! cargo test custom_set_tests::test_create_empty_set
//! ```
//!
//! ## References
//!
//! Based on set theory principles from:
//! - Discrete Mathematics and Its Applications (Rosen)

use set_theory::models::CustomSet;
use set_theory::operations::SetOperations;

/// Tests creating an empty set.
///
/// ## Summary
///
/// Verifies that an empty set has cardinality 0 and is correctly identified as empty.
///
/// ## Description
///
/// This test ensures the `CustomSet::empty()` constructor creates a valid
/// empty set with proper properties according to set theory.
///
/// ## Expected Behavior
///
/// - Cardinality should be 0
/// - `is_empty()` should return `true`
/// - Set should display as ∅
///
/// ## Examples
///
/// ```rust
/// let empty = CustomSet::<i32>::empty();
/// assert_eq!(empty.cardinality(), 0);
/// assert!(empty.is_empty());
/// ```
#[test]
fn test_create_empty_set() {
    let set = CustomSet::<i32>::empty();
    assert_eq!(set.cardinality(), 0, "Empty set should have cardinality 0");
    assert!(
        set.is_empty(),
        "Empty set should return true for is_empty()"
    );
    assert_eq!(format!("{}", set), "∅", "Empty set should display as ∅");
}

/// Tests creating a set with elements from a vector.
///
/// ## Summary
///
/// Verifies that a set created from a vector contains all unique elements.
///
/// ## Description
///
/// This test validates the `CustomSet::from()` constructor with a vector
/// of integers, ensuring proper element storage and membership checking.
///
/// ## Input
///
/// - Vector: `[1, 2, 3, 4]`
///
/// ## Expected Output
///
/// - Cardinality: 4
/// - Contains 1, 2, 3, 4: `true`
/// - Contains 5: `false`
///
/// ## Examples
///
/// ```rust
/// let set = CustomSet::from(vec![1, 2, 3, 4]);
/// assert!(set.contains(&1));
/// assert!(!set.contains(&5));
/// ```
#[test]
fn test_create_set_with_elements() {
    let set = CustomSet::from(vec![1, 2, 3, 4]);
    assert_eq!(set.cardinality(), 4, "Set should have 4 elements");
    assert!(set.contains(&1), "Set should contain 1");
    assert!(set.contains(&2), "Set should contain 2");
    assert!(set.contains(&3), "Set should contain 3");
    assert!(set.contains(&4), "Set should contain 4");
    assert!(!set.contains(&5), "Set should not contain 5");
}

/// Tests that duplicate elements are automatically removed.
///
/// ## Summary
///
/// Verifies that creating a set with duplicate elements results in unique elements only.
///
/// ## Description
///
/// According to set theory, a set cannot contain duplicate elements.
/// This test ensures the implementation follows this fundamental principle.
///
/// ## Input
///
/// - Vector with duplicates: `[1, 2, 2, 3, 3, 3]`
///
/// ## Expected Output
///
/// - Cardinality: 3 (not 6)
/// - Elements: `{1, 2, 3}`
///
/// ## Theory Reference
///
/// From set theory: `{1, 2, 2, 3, 3, 3} = {1, 2, 3}`
///
/// ## Examples
///
/// ```rust
/// let set = CustomSet::from(vec![1, 2, 2, 3, 3, 3]);
/// assert_eq!(set.cardinality(), 3);
/// ```
#[test]
fn test_duplicate_elements_removed() {
    let set = CustomSet::from(vec![1, 2, 2, 3, 3, 3]);
    assert_eq!(
        set.cardinality(),
        3,
        "Duplicate elements should be removed, cardinality should be 3"
    );
    assert!(set.contains(&1), "Set should contain 1");
    assert!(set.contains(&2), "Set should contain 2");
    assert!(set.contains(&3), "Set should contain 3");
}

/// Tests that element order does not affect set equality.
///
/// ## Summary
///
/// Verifies that sets with the same elements in different orders are equal.
///
/// ## Description
///
/// In set theory, order of elements does not matter. This test ensures
/// `{1, 2, 3} = {3, 2, 1}`.
///
/// ## Input
///
/// - Set 1: `[1, 2, 3]`
/// - Set 2: `[3, 2, 1]`
///
/// ## Expected Output
///
/// - Sets should be equal
///
/// ## Theory Reference
///
/// From set theory: `{a, b, c} = {c, b, a} = {b, a, c}`
///
/// ## Examples
///
/// ```rust
/// let set1 = CustomSet::from(vec![1, 2, 3]);
/// let set2 = CustomSet::from(vec![3, 2, 1]);
/// assert!(set1.equals(&set2));
/// ```
#[test]
fn test_order_does_not_matter() {
    let set1 = CustomSet::from(vec![1, 2, 3]);
    let set2 = CustomSet::from(vec![3, 2, 1]);
    let set3 = CustomSet::from(vec![2, 1, 3]);

    assert!(
        set1.equals(&set2),
        "Sets with same elements should be equal regardless of order"
    );
    assert!(
        set1.equals(&set3),
        "Sets with same elements should be equal regardless of order"
    );
    assert!(
        set2.equals(&set3),
        "Sets with same elements should be equal regardless of order"
    );
}

/// Tests subset operations.
///
/// ## Summary
///
/// Verifies `is_subset_of()` and `is_proper_subset_of()` methods.
///
/// ## Description
///
/// Tests the subset relationship between sets, including proper subset
/// distinction where A ⊂ B requires A ≠ B.
///
/// ## Notation
///
/// - A ⊆ B: A is a subset of B (A can equal B)
/// - A ⊂ B: A is a proper subset of B (A cannot equal B)
///
/// ## Input
///
/// - A = `{1, 2, 3}`
/// - B = `{1, 2, 3, 4, 5}`
///
/// ## Expected Output
///
/// - A ⊆ B: `true`
/// - B ⊆ A: `false`
/// - A ⊂ B: `true`
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// assert!(a.is_subset_of(&b));
/// assert!(a.is_proper_subset_of(&b));
/// ```
#[test]
fn test_subset_operations() {
    let a = CustomSet::from(vec![1, 2, 3]);
    let b = CustomSet::from(vec![1, 2, 3, 4, 5]);

    assert!(a.is_subset_of(&b), "A should be a subset of B");
    assert!(!b.is_subset_of(&a), "B should not be a subset of A");
    assert!(
        a.is_proper_subset_of(&b),
        "A should be a proper subset of B"
    );
    assert!(
        !b.is_proper_subset_of(&a),
        "B should not be a proper subset of A"
    );
}

/// Tests that empty set is a subset of any set.
///
/// ## Summary
///
/// Verifies the fundamental set theory principle that ∅ ⊆ A for all sets A.
///
/// ## Description
///
/// The empty set is a subset of every set, including itself. This is a
/// fundamental principle in set theory.
///
/// ## Theory Reference
///
/// From set theory: ∀A, ∅ ⊆ A
///
/// ## Expected Output
///
/// - ∅ ⊆ {1, 2, 3}: `true`
/// - ∅ ⊆ ∅: `true`
///
/// ## Examples
///
/// ```rust
/// let empty = CustomSet::<i32>::empty();
/// let any = CustomSet::from(vec![1, 2, 3]);
/// assert!(empty.is_subset_of(&any));
/// ```
#[test]
fn test_empty_set_is_subset() {
    let empty = CustomSet::<i32>::empty();
    let any = CustomSet::from(vec![1, 2, 3]);

    assert!(
        empty.is_subset_of(&any),
        "Empty set should be subset of any set"
    );
    assert!(
        empty.is_subset_of(&empty),
        "Empty set should be subset of itself"
    );
    assert!(
        !empty.is_proper_subset_of(&empty),
        "Empty set should not be proper subset of itself"
    );
}

/// Tests set intersection operation.
///
/// ## Summary
///
/// Verifies the intersection operation returns common elements.
///
/// ## Description
///
/// Tests A ∩ B = {x | x ∈ A and x ∈ B}
///
/// ## Notation
///
/// A ∩ B
///
/// ## Input
///
/// - A = `{2, 4, 6, 8, 10}`
/// - B = `{4, 10, 14, 18}`
///
/// ## Expected Output
///
/// - A ∩ B = `{4, 10}`
/// - Cardinality: 2
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![2, 4, 6, 8, 10]);
/// let b = CustomSet::from(vec![4, 10, 14, 18]);
/// let result = a.intersection(&b);
/// assert_eq!(result.cardinality(), 2);
/// ```
#[test]
fn test_intersection() {
    let a = CustomSet::from(vec![2, 4, 6, 8, 10]);
    let b = CustomSet::from(vec![4, 10, 14, 18]);
    let result = a.intersection(&b);

    assert_eq!(
        result.cardinality(),
        2,
        "Intersection should have 2 elements"
    );
    assert!(result.contains(&4), "Intersection should contain 4");
    assert!(result.contains(&10), "Intersection should contain 10");
    assert!(!result.contains(&2), "Intersection should not contain 2");
    assert!(!result.contains(&14), "Intersection should not contain 14");
}

/// Tests set union operation.
///
/// ## Summary
///
/// Verifies the union operation returns all unique elements from both sets.
///
/// ## Description
///
/// Tests A ∪ B = {x | x ∈ A or x ∈ B}
///
/// ## Notation
///
/// A ∪ B
///
/// ## Input
///
/// - A = `{2, 5, 8}`
/// - B = `{7, 5, 22}`
///
/// ## Expected Output
///
/// - A ∪ B = `{2, 5, 7, 8, 22}`
/// - Cardinality: 5
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![2, 5, 8]);
/// let b = CustomSet::from(vec![7, 5, 22]);
/// let result = a.union(&b);
/// assert_eq!(result.cardinality(), 5);
/// ```
#[test]
fn test_union() {
    let a = CustomSet::from(vec![2, 5, 8]);
    let b = CustomSet::from(vec![7, 5, 22]);
    let result = a.union(&b);

    assert_eq!(
        result.cardinality(),
        5,
        "Union should have 5 unique elements"
    );
    assert!(result.contains(&2), "Union should contain 2");
    assert!(result.contains(&5), "Union should contain 5");
    assert!(result.contains(&7), "Union should contain 7");
    assert!(result.contains(&8), "Union should contain 8");
    assert!(result.contains(&22), "Union should contain 22");
}

/// Tests set complement operation.
///
/// ## Summary
///
/// Verifies the complement operation returns elements in universal set not in A.
///
/// ## Description
///
/// Tests A' = {x | x ∈ U and x ∉ A}
///
/// ## Notation
///
/// A' or A̅
///
/// ## Input
///
/// - U = `{1, 2, 3, 4, 5, 6, 7, 8, 9}`
/// - A = `{1, 3, 7, 9}`
///
/// ## Expected Output
///
/// - A' = `{2, 4, 6, 8}`
/// - Cardinality: 5
///
/// ## Examples
///
/// ```rust
/// let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
/// let a = CustomSet::from(vec![1, 3, 7, 9]);
/// let result = a.complement(&universal);
/// assert_eq!(result.cardinality(), 5);
/// ```
#[test]
fn test_complement() {
    let universal = CustomSet::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
    let a = CustomSet::from(vec![1, 3, 7, 9]);
    let result = a.complement(&universal);

    assert_eq!(result.cardinality(), 5, "Complement should have 5 elements");
    assert!(result.contains(&2), "Complement should contain 2");
    assert!(result.contains(&4), "Complement should contain 4");
    assert!(result.contains(&6), "Complement should contain 6");
    assert!(result.contains(&8), "Complement should contain 8");
    assert!(!result.contains(&1), "Complement should not contain 1");
}

/// Tests set difference operation.
///
/// ## Summary
///
/// Verifies the difference operation returns elements in A but not in B.
///
/// ## Description
///
/// Tests A - B = {x | x ∈ A and x ∉ B}
///
/// ## Notation
///
/// A - B or A \ B
///
/// ## Input
///
/// - A = `{1, 2, 3, 4, 5}`
/// - B = `{2, 4}`
///
/// ## Expected Output
///
/// - A - B = `{1, 3, 5}`
/// - Cardinality: 3
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// let b = CustomSet::from(vec![2, 4]);
/// let result = a.difference(&b);
/// assert_eq!(result.cardinality(), 3);
/// ```
#[test]
fn test_difference() {
    let a = CustomSet::from(vec![1, 2, 3, 4, 5]);
    let b = CustomSet::from(vec![2, 4]);
    let result = a.difference(&b);

    assert_eq!(result.cardinality(), 3, "Difference should have 3 elements");
    assert!(result.contains(&1), "Difference should contain 1");
    assert!(result.contains(&3), "Difference should contain 3");
    assert!(result.contains(&5), "Difference should contain 5");
    assert!(!result.contains(&2), "Difference should not contain 2");
    assert!(!result.contains(&4), "Difference should not contain 4");
}

/// Tests symmetric difference operation.
///
/// ## Summary
///
/// Verifies the symmetric difference returns elements in either set but not both.
///
/// ## Description
///
/// Tests A ⊕ B = (A ∪ B) - (A ∩ B) = (A - B) ∪ (B - A)
///
/// ## Notation
///
/// A ⊕ B or A △ B
///
/// ## Input
///
/// - A = `{2, 4, 6}`
/// - B = `{2, 3, 5}`
///
/// ## Expected Output
///
/// - A ⊕ B = `{3, 4, 5, 6}`
/// - Cardinality: 4
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![2, 4, 6]);
/// let b = CustomSet::from(vec![2, 3, 5]);
/// let result = a.symmetric_difference(&b);
/// assert_eq!(result.cardinality(), 4);
/// ```
#[test]
fn test_symmetric_difference() {
    let a = CustomSet::from(vec![2, 4, 6]);
    let b = CustomSet::from(vec![2, 3, 5]);
    let result = a.symmetric_difference(&b);

    assert_eq!(
        result.cardinality(),
        4,
        "Symmetric difference should have 4 elements"
    );
    assert!(result.contains(&3), "Should contain 3");
    assert!(result.contains(&4), "Should contain 4");
    assert!(result.contains(&5), "Should contain 5");
    assert!(result.contains(&6), "Should contain 6");
    assert!(!result.contains(&2), "Should not contain 2 (in both sets)");
}

/// Tests power set generation.
///
/// ## Summary
///
/// Verifies the power set contains all possible subsets.
///
/// ## Description
///
/// Tests P(A) = 2^A where |P(A)| = 2^|A|
///
/// ## Notation
///
/// P(A) or 2^A
///
/// ## Input
///
/// - A = `{1, 2}`
///
/// ## Expected Output
///
/// - P(A) = `{∅, {1}, {2}, {1, 2}}`
/// - |P(A)| = 4 = 2^2
///
/// ## Theory Reference
///
/// If |A| = n, then |P(A)| = 2^n
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2]);
/// let power_set: Vec<_> = a.power_set().collect();
/// assert_eq!(power_set.len(), 4);
/// ```
#[test]
fn test_power_set() {
    let a = CustomSet::from(vec![1, 2]);
    let power_set: Vec<_> = a.power_set().collect();

    assert_eq!(power_set.len(), 4, "Power set should have 2^2 = 4 subsets");

    // Check for empty set
    assert!(
        power_set.iter().any(|s| s.is_empty()),
        "Power set should contain empty set"
    );

    // Check for original set
    assert!(
        power_set.iter().any(|s| s.equals(&a)),
        "Power set should contain original set"
    );

    // Check for single element subsets
    assert!(
        power_set
            .iter()
            .any(|s| s.cardinality() == 1 && s.contains(&1)),
        "Power set should contain {{1}}"
    );
    assert!(
        power_set
            .iter()
            .any(|s| s.cardinality() == 1 && s.contains(&2)),
        "Power set should contain {{2}}"
    );
}

/// Tests power set of empty set.
///
/// ## Summary
///
/// Verifies P(∅) = {∅} with cardinality 1.
///
/// ## Description
///
/// The power set of an empty set contains exactly one element: the empty set itself.
///
/// ## Theory Reference
///
/// P(∅) = {∅}, |P(∅)| = 2^0 = 1
///
/// ## Expected Output
///
/// - |P(∅)| = 1
///
/// ## Examples
///
/// ```rust
/// let empty = CustomSet::<i32>::empty();
/// let power_set: Vec<_> = empty.power_set().collect();
/// assert_eq!(power_set.len(), 1);
/// ```
#[test]
fn test_power_set_empty() {
    let empty = CustomSet::<i32>::empty();
    let power_set: Vec<_> = empty.power_set().collect();

    assert_eq!(
        power_set.len(),
        1,
        "Power set of empty set should have 2^0 = 1 subset"
    );
    assert!(
        power_set[0].is_empty(),
        "The only subset should be the empty set"
    );
}

/// Tests set creation from predicate.
///
/// ## Summary
///
/// Verifies sets can be created using a predicate function.
///
/// ## Description
///
/// Tests `CustomSet::from_predicate()` which filters elements from a universe
/// based on a condition.
///
/// ## Input
///
/// - Universe: `0..10`
/// - Predicate: `x % 2 == 0` (even numbers)
///
/// ## Expected Output
///
/// - Set = `{0, 2, 4, 6, 8}`
/// - Cardinality: 5
///
/// ## Examples
///
/// ```rust
/// let evens = CustomSet::from_predicate(0..10, |x| x % 2 == 0);
/// assert_eq!(evens.cardinality(), 5);
/// ```
#[test]
fn test_from_predicate() {
    let evens = CustomSet::from_predicate(0..10, |x| x % 2 == 0);

    assert_eq!(
        evens.cardinality(),
        5,
        "Should have 5 even numbers from 0-9"
    );
    assert!(evens.contains(&0), "Should contain 0");
    assert!(evens.contains(&2), "Should contain 2");
    assert!(evens.contains(&4), "Should contain 4");
    assert!(evens.contains(&6), "Should contain 6");
    assert!(evens.contains(&8), "Should contain 8");
    assert!(!evens.contains(&1), "Should not contain 1");
    assert!(!evens.contains(&3), "Should not contain 3");
}

/// Tests disjoint sets.
///
/// ## Summary
///
/// Verifies `is_disjoint_from()` correctly identifies sets with no common elements.
///
/// ## Description
///
/// Two sets are disjoint if their intersection is the empty set.
///
/// ## Notation
///
/// A // B means A ∩ B = ∅
///
/// ## Input
///
/// - A = `{1, 2, 3}`
/// - B = `{4, 5, 6}`
/// - C = `{3, 4, 5}`
///
/// ## Expected Output
///
/// - A // B: `true`
/// - A // C: `false`
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![4, 5, 6]);
/// assert!(a.is_disjoint_from(&b));
/// ```
#[test]
fn test_disjoint() {
    let a = CustomSet::from(vec![1, 2, 3]);
    let b = CustomSet::from(vec![4, 5, 6]);
    let c = CustomSet::from(vec![3, 4, 5]);

    assert!(a.is_disjoint_from(&b), "A and B should be disjoint");
    assert!(
        !a.is_disjoint_from(&c),
        "A and C should not be disjoint (share 3)"
    );
    assert!(
        !b.is_disjoint_from(&c),
        "B and C should not be disjoint (share 4, 5)"
    );
}

/// Tests add and remove operations.
///
/// ## Summary
///
/// Verifies mutable operations on sets.
///
/// ## Description
///
/// Tests adding and removing elements from a mutable set.
///
/// ## Expected Behavior
///
/// - `add()` returns `true` if element was added, `false` if already exists
/// - `remove()` returns `true` if element was removed, `false` if not found
///
/// ## Examples
///
/// ```rust
/// let mut set = CustomSet::from(vec![1, 2]);
/// assert!(set.add(3));
/// assert!(!set.add(3)); // Already exists
/// ```
#[test]
fn test_add_remove() {
    let mut set = CustomSet::from(vec![1, 2]);

    // Test add
    assert!(set.add(3), "Add should return true for new element");
    assert_eq!(set.cardinality(), 3, "Cardinality should increase");
    assert!(!set.add(3), "Add should return false for existing element");
    assert_eq!(set.cardinality(), 3, "Cardinality should not change");

    // Test remove
    assert!(
        set.remove(&2),
        "Remove should return true for existing element"
    );
    assert_eq!(set.cardinality(), 2, "Cardinality should decrease");
    assert!(
        !set.remove(&2),
        "Remove should return false for non-existing element"
    );
    assert_eq!(set.cardinality(), 2, "Cardinality should not change");
}

/// Tests clear operation.
///
/// ## Summary
///
/// Verifies that `clear()` removes all elements from the set.
///
/// ## Expected Output
///
/// - Set should be empty after clear
/// - Cardinality should be 0
///
/// ## Examples
///
/// ```rust
/// let mut set = CustomSet::from(vec![1, 2, 3]);
/// set.clear();
/// assert!(set.is_empty());
/// ```
#[test]
fn test_clear() {
    let mut set = CustomSet::from(vec![1, 2, 3]);
    set.clear();

    assert!(set.is_empty(), "Set should be empty after clear");
    assert_eq!(set.cardinality(), 0, "Cardinality should be 0 after clear");
}

/// Tests set iteration.
///
/// ## Summary
///
/// Verifies that sets can be iterated over.
///
/// ## Description
///
/// Tests the `IntoIterator` implementation for CustomSet.
///
/// ## Examples
///
/// ```rust
/// let set = CustomSet::from(vec![1, 2, 3]);
/// for element in set.iter() {
///     println!("{}", element);
/// }
/// ```
#[test]
fn test_iteration() {
    let set = CustomSet::from(vec![1, 2, 3, 4, 5]);
    let mut count = 0;
    let mut sum = 0;

    for element in set.iter() {
        count += 1;
        sum += element;
    }

    assert_eq!(count, 5, "Should iterate over all 5 elements");
    assert_eq!(sum, 15, "Sum should be 1+2+3+4+5 = 15");
}

/// Tests set display formatting.
///
/// ## Summary
///
/// Verifies the `Display` trait implementation.
///
/// ## Expected Output
///
/// - Empty set: "∅"
/// - Non-empty set: "{1, 2, 3}"
///
/// ## Examples
///
/// ```rust
/// let set = CustomSet::from(vec![1, 2, 3]);
/// println!("{}", set); // {1, 2, 3}
/// ```
#[test]
fn test_display() {
    let set = CustomSet::from(vec![1, 2, 3]);
    let display = format!("{}", set);

    assert!(display.starts_with("{"), "Display should start with {{");
    assert!(display.ends_with("}"), "Display should end with }}");
    assert!(display.contains("1"), "Display should contain 1");
    assert!(display.contains("2"), "Display should contain 2");
    assert!(display.contains("3"), "Display should contain 3");

    let empty = CustomSet::<i32>::empty();
    assert_eq!(format!("{}", empty), "∅", "Empty set should display as ∅");
}

/// Tests set equality operator.
///
/// ## Summary
///
/// Verifies the `PartialEq` and `Eq` trait implementations.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// let b = CustomSet::from(vec![3, 2, 1]);
/// assert_eq!(a, b);
/// ```
#[test]
fn test_equality() {
    let a = CustomSet::from(vec![1, 2, 3]);
    let b = CustomSet::from(vec![3, 2, 1]);
    let c = CustomSet::from(vec![1, 2, 4]);

    assert_eq!(a, b, "Sets with same elements should be equal");
    assert_ne!(a, c, "Sets with different elements should not be equal");
}

/// Tests set with itself operations.
///
/// ## Summary
///
/// Verifies operations when a set is operated with itself.
///
/// ## Expected Results
///
/// - A ∪ A = A
/// - A ∩ A = A
/// - A - A = ∅
/// - A ⊕ A = ∅
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3]);
/// assert_eq!(SetOperations::union(&a, &a), a);
/// ```
#[test]
fn test_set_with_itself() {
    let a = CustomSet::from(vec![1, 2, 3]);

    assert_eq!(SetOperations::union(&a, &a), a, "A ∪ A should equal A");
    assert_eq!(
        SetOperations::intersection(&a, &a),
        a,
        "A ∩ A should equal A"
    );
    assert!(
        SetOperations::difference(&a, &a).is_empty(),
        "A - A should be empty"
    );
    assert!(
        SetOperations::symmetric_difference(&a, &a).is_empty(),
        "A ⊕ A should be empty"
    );
}

/// Tests nested sets.
///
/// ## Summary
///
/// Verifies that sets can contain other sets as elements.
///
/// ## Description
///
/// Tests the ability to create sets with nested set elements,
/// following set theory principles where sets can be elements of other sets.
///
/// ## Theory Reference
///
/// From set theory: {a, b, {a, b, c}, {a, c}} is a valid set
///
/// ## Examples
///
/// ```rust
/// use set_theory::models::CustomSet;
///
/// let inner1 = CustomSet::from(vec!['a', 'b', 'c']);
/// let inner2 = CustomSet::from(vec!['a', 'c']);
/// let outer = CustomSet::from(vec![inner1.clone(), inner2.clone()]);
/// assert_eq!(outer.cardinality(), 2);
/// ```
#[test]
fn test_nested_sets() {
    let inner_set1 = CustomSet::from(vec!['a', 'b', 'c']);
    let inner_set1_reordered = CustomSet::from(vec!['c', 'b', 'a']);
    let inner_set2 = CustomSet::from(vec!['a', 'c']);

    assert_eq!(
        inner_set1, inner_set1_reordered,
        "Inner sets with same elements should be equal regardless of order"
    );

    let outer_set = CustomSet::from(vec![inner_set1.clone(), inner_set2.clone()]);

    assert_eq!(
        outer_set.cardinality(),
        2,
        "Outer set should have 2 inner sets as elements"
    );

    assert!(
        outer_set.contains(&inner_set1),
        "Outer set should contain inner_set1"
    );
    assert!(
        outer_set.contains(&inner_set2),
        "Outer set should contain inner_set2"
    );

    let outer_set_reordered =
        CustomSet::from(vec![inner_set2.clone(), inner_set1_reordered.clone()]);

    assert_eq!(
        outer_set, outer_set_reordered,
        "Outer sets should be equal regardless of element order"
    );
}

/// Tests superset operations.
///
/// ## Summary
///
/// Verifies `is_superset_of()` and `is_proper_superset_of()` methods.
///
/// ## Notation
///
/// - A ⊇ B: A is a superset of B
/// - A ⊃ B: A is a proper superset of B
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3, 4, 5]);
/// let b = CustomSet::from(vec![1, 2, 3]);
/// assert!(a.is_superset_of(&b));
/// ```
#[test]
fn test_superset_operations() {
    let a = CustomSet::from(vec![1, 2, 3, 4, 5]);
    let b = CustomSet::from(vec![1, 2, 3]);

    assert!(a.is_superset_of(&b), "A should be a superset of B");
    assert!(!b.is_superset_of(&a), "B should not be a superset of A");
    assert!(
        a.is_proper_superset_of(&b),
        "A should be a proper superset of B"
    );
    assert!(
        !b.is_proper_superset_of(&a),
        "B should not be a proper superset of A"
    );
}

/// Tests set equivalence (same cardinality).
///
/// ## Summary
///
/// Verifies `is_equivalent_to()` checks cardinality equality.
///
/// ## Notation
///
/// A ~ B means |A| = |B|
///
/// ## Description
///
/// Two sets are equivalent if they have the same cardinality,
/// regardless of the actual elements.
///
/// ## Examples
///
/// ```rust
/// let a = CustomSet::from(vec![1, 2, 3, 4]);
/// let b = CustomSet::from(vec!['a', 'b', 'c', 'd']);
/// assert!(a.is_equivalent_to(&b));
/// ```
#[test]
fn test_equivalence() {
    let a = CustomSet::from(vec![1, 2, 3, 4]);
    let b = CustomSet::from(vec!['a', 'b', 'c', 'd']);
    let c = CustomSet::from(vec![1, 2, 3]);

    assert!(
        a.is_equivalent_to(&b),
        "Sets with same cardinality should be equivalent"
    );
    assert!(
        !a.is_equivalent_to(&c),
        "Sets with different cardinality should not be equivalent"
    );
}

/// Tests edge case with empty set operations.
///
/// ## Summary
///
/// Verifies operations involving empty sets.
///
/// ## Expected Results
///
/// - ∅ ∪ ∅ = ∅
/// - ∅ ∩ A = ∅
/// - A - ∅ = A
/// - ∅ - A = ∅
///
/// ## Examples
///
/// ```rust
/// let empty = CustomSet::<i32>::empty();
/// let non_empty = CustomSet::from(vec![1, 2, 3]);
/// assert!(SetOperations::union(&empty, &empty).is_empty());
/// ```
#[test]
fn test_empty_set_operations() {
    let empty = CustomSet::<i32>::empty();
    let non_empty = CustomSet::from(vec![1, 2, 3]);

    assert!(SetOperations::union(&empty, &empty).is_empty(), "∅ ∪ ∅ = ∅");
    assert!(
        SetOperations::intersection(&empty, &non_empty).is_empty(),
        "∅ ∩ A = ∅"
    );
    assert_eq!(
        SetOperations::difference(&non_empty, &empty),
        non_empty,
        "A - ∅ = A"
    );
    assert!(
        SetOperations::difference(&empty, &non_empty).is_empty(),
        "∅ - A = ∅"
    );
}