ronn-providers 0.1.0

//! Basic tests for providers
//!
//! These are simplified tests to verify basic functionality compiles and runs.

use ronn_core::{DataType, GraphNode, SubGraph, Tensor, TensorLayout};
use ronn_providers::{
    GpuTopologyManager, ProviderRegistry, TopologyConfig, create_cpu_provider,
    create_provider_system,
};
use std::collections::HashMap;

#[test]
fn test_cpu_provider_creation() {
    let provider = create_cpu_provider();
    assert!(provider.is_ok(), "Should be able to create CPU provider");
}

#[test]
fn test_provider_registry() {
    let registry = ProviderRegistry::new();

    // Register CPU provider
    let cpu_provider = create_cpu_provider().expect("Failed to create CPU provider");
    let result = registry.register_provider(cpu_provider);
    assert!(result.is_ok(), "Should be able to register CPU provider");

    // Get statistics
    let stats = registry.get_statistics();
    assert_eq!(stats.provider_count, 1);
    assert!(!stats.preference_order.is_empty());
}

#[test]
fn test_provider_system_creation() {
    let system = create_provider_system();
    assert!(system.is_ok(), "Should be able to create provider system");

    let registry = system.unwrap();
    let stats = registry.get_statistics();

    // Should have at least CPU provider
    assert!(stats.provider_count >= 1);
}

#[test]
fn test_simple_kernel_compilation() {
    let registry = create_provider_system().expect("Failed to create provider system");

    // Create a simple subgraph
    let subgraph = SubGraph {
        nodes: vec![GraphNode {
            id: 0,
            op_type: "Add".to_string(),
            attributes: HashMap::new(),
            inputs: vec!["a".to_string(), "b".to_string()],
            outputs: vec!["c".to_string()],
            name: Some("add_op".to_string()),
        }],
        edges: vec![],
        inputs: vec!["a".to_string(), "b".to_string()],
        outputs: vec!["c".to_string()],
    };

    // Try to compile the subgraph
    let result = registry.compile_subgraph(subgraph);
    assert!(result.is_ok(), "Should be able to compile simple subgraph");
}

#[test]
fn test_topology_config_creation() {
    let config = TopologyConfig {
        auto_discovery: true,
        benchmark_links: false,
        cache_topology: true,
        benchmark_duration_ms: 100,
        benchmark_iterations: 3,
        consider_numa: false,
    };

    assert!(config.auto_discovery);
    assert_eq!(config.benchmark_duration_ms, 100);
}

#[test]
fn test_gpu_topology_manager_creation() {
    let config = TopologyConfig {
        auto_discovery: false, // Don't auto-discover to avoid hardware dependencies
        benchmark_links: false,
        cache_topology: false,
        benchmark_duration_ms: 100,
        benchmark_iterations: 1,
        consider_numa: false,
    };

    let manager = GpuTopologyManager::new(config).expect("Failed to create GpuTopologyManager");

    // Basic test - just ensure it creates successfully
    let topology = manager.get_topology();

    // Topology should exist even if empty
    assert_eq!(
        topology.devices.len(),
        0,
        "No devices when auto_discovery is off"
    );
}

#[test]
fn test_tensor_operations() {
    // Create test tensors
    let tensor1 = Tensor::ones(vec![2, 2], DataType::F32, TensorLayout::RowMajor)
        .expect("Failed to create tensor");
    let tensor2 = Tensor::ones(vec![2, 2], DataType::F32, TensorLayout::RowMajor)
        .expect("Failed to create tensor");

    // Basic checks
    assert_eq!(tensor1.shape(), &[2, 2]);
    assert_eq!(tensor1.dtype(), DataType::F32);

    // Test tensor addition through provider
    let registry = create_provider_system().expect("Failed to create provider system");

    let subgraph = SubGraph {
        nodes: vec![GraphNode {
            id: 0,
            op_type: "Add".to_string(),
            attributes: HashMap::new(),
            inputs: vec!["input1".to_string(), "input2".to_string()],
            outputs: vec!["output".to_string()],
            name: Some("test_add".to_string()),
        }],
        edges: vec![],
        inputs: vec!["input1".to_string(), "input2".to_string()],
        outputs: vec!["output".to_string()],
    };

    let (provider_id, kernel) = registry
        .compile_subgraph(subgraph)
        .expect("Failed to compile subgraph");

    assert_eq!(provider_id, ronn_core::ProviderId::CPU);

    let inputs = vec![tensor1, tensor2];
    let outputs = kernel.execute(&inputs).expect("Failed to execute kernel");

    assert_eq!(outputs.len(), 1);

    // Debug: print actual shape
    println!("Output shape: {:?}", outputs[0].shape());

    // The output might be flattened or have different dimensions
    let total_elements: usize = outputs[0].shape().iter().product();
    assert!(total_elements > 0, "Output should have elements");
}