106 lines
2.9 KiB
Rust
106 lines
2.9 KiB
Rust
// TDD: RED phase - Write tests first for error types
|
|
use rtx_cfd::error::{CfdError, CfdResult};
|
|
|
|
#[test]
|
|
fn test_gpu_memory_error_creation() {
|
|
let error = CfdError::GpuMemoryError("Out of GPU memory".to_string());
|
|
match error {
|
|
CfdError::GpuMemoryError(msg) => assert_eq!(msg, "Out of GPU memory"),
|
|
_ => panic!("Expected GpuMemoryError"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_convergence_error_creation() {
|
|
let error = CfdError::ConvergenceError {
|
|
iteration: 100,
|
|
residual: 1e-3,
|
|
target: 1e-6,
|
|
};
|
|
match error {
|
|
CfdError::ConvergenceError {
|
|
iteration,
|
|
residual,
|
|
target,
|
|
} => {
|
|
assert_eq!(iteration, 100);
|
|
assert_eq!(residual, 1e-3);
|
|
assert_eq!(target, 1e-6);
|
|
}
|
|
_ => panic!("Expected ConvergenceError"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_mesh_error_creation() {
|
|
let error = CfdError::MeshError("Invalid mesh topology".to_string());
|
|
match error {
|
|
CfdError::MeshError(msg) => assert_eq!(msg, "Invalid mesh topology"),
|
|
_ => panic!("Expected MeshError"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_solver_error_creation() {
|
|
let error = CfdError::SolverError("Matrix is singular".to_string());
|
|
match error {
|
|
CfdError::SolverError(msg) => assert_eq!(msg, "Matrix is singular"),
|
|
_ => panic!("Expected SolverError"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_boundary_condition_error_creation() {
|
|
let error = CfdError::BoundaryConditionError("Incompatible BC types".to_string());
|
|
match error {
|
|
CfdError::BoundaryConditionError(msg) => assert_eq!(msg, "Incompatible BC types"),
|
|
_ => panic!("Expected BoundaryConditionError"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_cuda_error_conversion() {
|
|
// Test that CUDA errors can be converted to CfdError
|
|
let cfd_error = CfdError::CudaError("Test CUDA error".to_string());
|
|
match cfd_error {
|
|
CfdError::CudaError(_) => (),
|
|
_ => panic!("Expected CudaError conversion"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_error_display() {
|
|
let error = CfdError::ConvergenceError {
|
|
iteration: 50,
|
|
residual: 1e-4,
|
|
target: 1e-6,
|
|
};
|
|
let display_str = format!("{}", error);
|
|
println!("Display string: {}", display_str);
|
|
assert!(display_str.contains("Convergence failed"));
|
|
assert!(display_str.contains("50"));
|
|
assert!(
|
|
display_str.contains("1.00e-4")
|
|
|| display_str.contains("1e-4")
|
|
|| display_str.contains("0.0001")
|
|
);
|
|
assert!(
|
|
display_str.contains("1.00e-6")
|
|
|| display_str.contains("1e-6")
|
|
|| display_str.contains("0.000001")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_cfd_result_ok() {
|
|
let result: CfdResult<i32> = Ok(42);
|
|
assert!(result.is_ok());
|
|
assert_eq!(result.unwrap(), 42);
|
|
}
|
|
|
|
#[test]
|
|
fn test_cfd_result_err() {
|
|
let result: CfdResult<i32> = Err(CfdError::MeshError("Test error".to_string()));
|
|
assert!(result.is_err());
|
|
}
|