brlapi 0.4.1

// SPDX-License-Identifier: LGPL-2.1

//! Tests for BrlAPI suspend mode functionality
//!
//! These tests verify the suspend mode implementation while handling the fact
//! that most test environments don't have hardware that supports suspension.

#[cfg(feature = "dangerous-suspend-mode")]
mod suspend_tests {
    use brlapi::{BrlApiError, Connection, suspend::SuspendMode};

    /// Common test helper to try connecting
    fn try_connect() -> Result<Connection, BrlApiError> {
        Connection::open().or_else(|_| {
            // If connection fails, create a mock or skip test
            Err(BrlApiError::custom(
                "No BrlAPI daemon available for testing",
            ))
        })
    }

    #[test]
    fn test_driver_support_detection() {
        // Test drivers that don't support suspend
        assert!(!SuspendMode::is_driver_supported("nb"));
        assert!(!SuspendMode::is_driver_supported("NoBraille"));
        assert!(!SuspendMode::is_driver_supported("fake"));
        assert!(!SuspendMode::is_driver_supported("test"));
        assert!(!SuspendMode::is_driver_supported("dummy"));

        // Test drivers that should support suspend
        assert!(SuspendMode::is_driver_supported("baum"));
        assert!(SuspendMode::is_driver_supported("hims"));
        assert!(SuspendMode::is_driver_supported("alva"));
        assert!(SuspendMode::is_driver_supported("papenmeier"));
        assert!(SuspendMode::is_driver_supported("freedom"));
        assert!(SuspendMode::is_driver_supported("unknown_driver"));
    }

    #[test]
    fn test_input_validation() {
        // These tests check input validation without requiring BrlAPI daemon
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping suspend mode input validation tests - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        // Test empty driver name
        let result = SuspendMode::enter(&connection, "");
        assert!(result.is_err());
        if let Err(e) = result {
            assert!(e.to_string().contains("empty"));
        }

        // Test driver name with null bytes
        let result = SuspendMode::enter(&connection, "driver\0name");
        assert!(result.is_err());
        if let Err(e) = result {
            assert!(e.to_string().contains("null bytes"));
        }
    }

    #[test]
    fn test_suspend_mode_with_current_driver() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping suspend mode current driver test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        // Get current driver
        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        println!(
            "Testing suspend mode with current driver: {}",
            current_driver
        );

        // Test suspend mode entry
        match SuspendMode::enter(&connection, &current_driver) {
            Ok(suspend_mode) => {
                println!(
                    "SUCCESS: Entered suspend mode with driver '{}'",
                    current_driver
                );

                // Test suspend mode state
                assert!(suspend_mode.is_suspended());
                assert_eq!(suspend_mode.driver_name(), current_driver);

                // Driver should be automatically resumed when suspend_mode is dropped
                println!("Suspend mode will be automatically resumed via Drop trait");
            }
            Err(e) => {
                println!(
                    "EXPECTED: Suspend mode failed with driver '{}': {}",
                    current_driver, e
                );
                println!("This is normal for most drivers/configurations");

                // For NoBraille driver, this should definitely fail
                if current_driver == "nb" || current_driver == "NoBraille" {
                    assert!(
                        e.to_string().contains("not currently active")
                            || e.to_string().contains("suspend")
                            || e.to_string().contains("not supported")
                    );
                }
            }
        }
    }

    #[test]
    fn test_suspend_mode_with_wrong_driver() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping suspend mode wrong driver test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        // Get current driver
        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        // Try to suspend a different driver than what's currently active
        let wrong_driver = if current_driver == "baum" {
            "hims"
        } else {
            "baum"
        };

        println!(
            "Testing suspend mode with wrong driver: {} (current: {})",
            wrong_driver, current_driver
        );

        let result = SuspendMode::enter(&connection, &wrong_driver);
        assert!(result.is_err());

        if let Err(e) = result {
            let error_msg = e.to_string();
            assert!(error_msg.contains("not currently active") || error_msg.contains("not found"));
            println!("EXPECTED: Got appropriate error for wrong driver: {}", e);
        }
    }

    #[test]
    fn test_manual_resume() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping manual resume test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        // Get current driver
        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        // Try manual resume without suspension first
        match SuspendMode::enter(&connection, &current_driver) {
            Ok(mut suspend_mode) => {
                println!("Testing manual resume with driver '{}'", current_driver);

                assert!(suspend_mode.is_suspended());

                // Test manual resume
                match suspend_mode.resume() {
                    Ok(()) => {
                        println!("SUCCESS: Manual resume succeeded");
                        assert!(!suspend_mode.is_suspended());

                        // Test double resume (should fail)
                        let double_resume = suspend_mode.resume();
                        assert!(double_resume.is_err());
                        if let Err(e) = double_resume {
                            assert!(e.to_string().contains("not currently suspended"));
                        }
                    }
                    Err(e) => {
                        println!("Manual resume failed: {}", e);
                        // This might be expected depending on driver support
                    }
                }
            }
            Err(e) => {
                println!("Cannot enter suspend mode for manual resume test: {}", e);
                println!("This is expected for most test configurations");
            }
        }
    }

    #[test]
    fn test_suspend_mode_state_tracking() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping state tracking test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        match SuspendMode::enter(&connection, &current_driver) {
            Ok(suspend_mode) => {
                println!("Testing state tracking with driver '{}'", current_driver);

                // Test initial state
                assert!(suspend_mode.is_suspended());
                assert_eq!(suspend_mode.driver_name(), current_driver);

                // State should remain consistent
                assert!(suspend_mode.is_suspended());
                assert_eq!(suspend_mode.driver_name(), current_driver);

                println!("State tracking test passed");
            }
            Err(e) => {
                println!("Cannot enter suspend mode for state tracking test: {}", e);
                println!("This is expected for most test configurations");
            }
        }
    }

    #[test]
    fn test_suspend_mode_drop_cleanup() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping drop cleanup test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        match SuspendMode::enter(&connection, &current_driver) {
            Ok(suspend_mode) => {
                println!(
                    "Testing automatic cleanup via Drop trait with driver '{}'",
                    current_driver
                );

                assert!(suspend_mode.is_suspended());

                // When suspend_mode goes out of scope here, Drop should automatically resume
                drop(suspend_mode);

                println!("Drop cleanup completed - driver should be resumed");

                // We can't directly verify the driver was resumed without more complex
                // state tracking, but the Drop implementation should handle it
            }
            Err(e) => {
                println!("Cannot enter suspend mode for drop cleanup test: {}", e);
                println!("This is expected for most test configurations");
            }
        }
    }

    #[test]
    fn test_error_conditions() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping error conditions test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        // Test various error conditions
        let error_cases = [
            ("", "empty driver name"),
            ("nonexistent_driver_123", "nonexistent driver"),
            ("driver\0with\0nulls", "null bytes in name"),
        ];

        for (driver_name, description) in error_cases.iter() {
            println!("Testing error condition: {}", description);

            let result = SuspendMode::enter(&connection, driver_name);
            assert!(result.is_err(), "Expected error for {}", description);

            if let Err(e) = result {
                println!("Got expected error for {}: {}", description, e);
            }
        }
    }

    #[test]
    fn test_concurrent_suspend_prevention() {
        let connection = try_connect();

        // Skip if no daemon available
        if connection.is_err() {
            println!("Skipping concurrent suspend test - no BrlAPI daemon");
            return;
        }

        let connection = connection.unwrap();

        let current_driver = match connection.display_driver() {
            Ok(driver) => driver,
            Err(e) => {
                println!("Cannot get current driver: {} - skipping test", e);
                return;
            }
        };

        match SuspendMode::enter(&connection, &current_driver) {
            Ok(_suspend_mode1) => {
                println!("First suspend mode entered successfully");

                // Try to enter suspend mode again with same driver - should fail
                let result2 = SuspendMode::enter(&connection, &current_driver);
                match result2 {
                    Ok(_) => {
                        println!(
                            "WARNING: Second suspend mode succeeded - this may not be expected"
                        );
                    }
                    Err(e) => {
                        println!("EXPECTED: Second suspend mode failed: {}", e);
                        // This is the expected behavior - only one suspend mode at a time
                    }
                }

                // _suspend_mode1 will be automatically cleaned up
            }
            Err(e) => {
                println!("Cannot enter suspend mode for concurrent test: {}", e);
                println!("This is expected for most test configurations");
            }
        }
    }
}

// Tests that run even without the feature flag
#[test]
fn test_feature_flag_requirement() {
    // This test verifies that suspend mode is properly feature-gated

    #[cfg(feature = "dangerous-suspend-mode")]
    {
        // Feature is enabled - suspend module should be available
        let _ = brlapi::suspend::SuspendMode::is_driver_supported("test");
        println!("Suspend mode feature is enabled");
    }

    #[cfg(not(feature = "dangerous-suspend-mode"))]
    {
        // Feature is disabled - suspend module should not be available
        // This test just verifies the feature flag works correctly
        println!("Suspend mode feature is disabled (as expected without feature flag)");
    }
}