//! Tests for DistributedContext

use super::*;
use crate::backend::Backend;
use crate::distributed_context::DistributedContext;

#[test]
fn test_uninitialized_context() {
    let ctx = DistributedContext::uninitialized();

    assert!(!ctx.is_initialized());
    assert_eq!(ctx.rank(), 0);
    assert_eq!(ctx.world_size(), 1);
    assert_eq!(ctx.local_rank(), 0);
    assert_eq!(ctx.local_world_size(), 1);
    assert!(ctx.is_master());
}

#[test]
fn test_default_context() {
    let ctx = DistributedContext::default();

    assert!(!ctx.is_initialized());
    assert!(ctx.is_master());
}

#[test]
fn test_context_rank_queries() {
    let ctx = DistributedContext::uninitialized();

    assert!(ctx.is_rank(0));
    assert!(!ctx.is_rank(1));
    assert!(ctx.is_master());
}

#[test]
fn test_context_info_string() {
    let ctx = DistributedContext::uninitialized();
    let info = ctx.info_string();

    assert!(info.contains("Not initialized"));
    assert!(info.contains("single GPU"));
}

#[tokio::test]
async fn test_barrier_uninitialized() {
    let ctx = DistributedContext::uninitialized();

    // Should not fail on uninitialized context
    let result = ctx.barrier().await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_broadcast_uninitialized() {
    let ctx = DistributedContext::uninitialized();
    let mut data = 42u32;

    // Should not fail on uninitialized context
    let result = ctx.broadcast(&mut data, 0).await;
    assert!(result.is_ok());
    assert_eq!(data, 42); // Data should remain unchanged
}

#[test]
fn test_backend_access() {
    let ctx = DistributedContext::uninitialized();
    let backend = ctx.backend();

    // Should have some backend set
    assert!(matches!(
        backend,
        Backend::Nccl | Backend::Rccl | Backend::Mpi | Backend::Cpu
    ));
}