#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use crate::services::wasm;
#[test]
fn test_wasm_error_integration() {
let parse_err = wasm::WasmError::parse("Test parse error");
assert_eq!(parse_err.to_string(), "Parse error: Test parse error");
let format_err = wasm::WasmError::format("Test format error");
assert_eq!(format_err.to_string(), "Invalid format: Test format error");
let analysis_err = wasm::WasmError::analysis("Test analysis error");
assert_eq!(
analysis_err.to_string(),
"Analysis error: Test analysis error"
);
let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "File not found");
let wasm_io_err: wasm::WasmError = io_err.into();
assert!(wasm_io_err.to_string().contains("File not found"));
let anyhow_err = anyhow::anyhow!("Generic error");
let wasm_other_err: wasm::WasmError = anyhow_err.into();
assert_eq!(wasm_other_err.to_string(), "Other error: Generic error");
let ok_result: wasm::WasmResult<i32> = Ok(42);
assert!(ok_result.is_ok());
let err_result: wasm::WasmResult<i32> = Err(wasm::WasmError::parse("Failed"));
assert!(err_result.is_err());
}
#[test]
fn test_memory_pool_integration() {
use crate::services::wasm::memory_pool::MemoryPool;
let pool = MemoryPool::new(1024 * 1024);
assert_eq!(pool.max_size(), 1024 * 1024);
let default_pool = MemoryPool::default();
assert_eq!(default_pool.max_size(), 64 * 1024 * 1024);
let small_pool = MemoryPool::new(512);
assert_eq!(small_pool.max_size(), 512);
let large_pool = MemoryPool::new(256 * 1024 * 1024);
assert_eq!(large_pool.max_size(), 256 * 1024 * 1024);
}
#[test]
fn test_types_integration() {
use crate::services::wasm::types::*;
let variants = vec![
WebAssemblyVariant::AssemblyScript,
WebAssemblyVariant::Wat,
WebAssemblyVariant::Wasm,
];
for variant in &variants {
assert_eq!(variant, variant);
let _ = format!("{:?}", variant);
}
let mut metrics = WasmMetrics {
function_count: 10,
import_count: 5,
..Default::default()
};
metrics.instruction_histogram.insert(WasmOpcode::Call, 20);
assert_eq!(metrics.function_count, 10);
assert_eq!(
*metrics
.instruction_histogram
.get(&WasmOpcode::Call)
.unwrap(),
20
);
let stats = MemoryOpStats {
loads: 100,
stores: 50,
grows: 2,
atomic_ops: 10,
simd_ops: 5,
bulk_ops: 3,
};
assert_eq!(stats.loads, 100);
assert_eq!(stats.stores, 50);
let complexity = WasmComplexity {
cyclomatic: 15,
memory_pressure: 80.5,
indirect_call_overhead: 2.5,
estimated_gas: 2000.0,
cognitive: 20,
hot_path_score: 0.9,
max_loop_depth: 4,
};
assert_eq!(complexity.cyclomatic, 15);
assert_eq!(complexity.memory_pressure, 80.5);
assert_eq!(Severity::Low.to_string(), "Low");
assert_eq!(Severity::Medium.to_string(), "Medium");
assert_eq!(Severity::High.to_string(), "High");
assert_eq!(Severity::Critical.to_string(), "Critical");
assert!(Severity::Low < Severity::Critical);
assert_eq!(WasmOpcode::from(0x00), WasmOpcode::Unreachable);
assert_eq!(WasmOpcode::from(0x10), WasmOpcode::Call);
assert_eq!(WasmOpcode::from(0x28), WasmOpcode::I32Load);
assert_eq!(WasmOpcode::from(0xFF), WasmOpcode::Other(0xFF));
}
#[test]
fn test_traits_integration() {
use crate::models::unified_ast::{AstDag, Language};
use crate::services::wasm::traits::*;
use std::collections::HashMap;
let mut metadata = HashMap::new();
metadata.insert("version".to_string(), "1.0".to_string());
let ast = ParsedAst {
language: Language::WebAssembly,
dag: AstDag::new(),
source_file: Some(std::path::PathBuf::from("test.wasm")),
parse_errors: vec!["Error 1".to_string(), "Error 2".to_string()],
metadata,
};
assert_eq!(ast.language, Language::WebAssembly);
assert_eq!(ast.parse_errors.len(), 2);
assert!(ast.source_file.is_some());
assert_eq!(ast.metadata.get("version"), Some(&"1.0".to_string()));
let default_caps = WasmAnalysisCapabilities::default();
assert!(default_caps.memory_analysis);
assert!(default_caps.gas_estimation);
assert!(default_caps.security_analysis);
assert!(default_caps.optimization_hints);
assert!(default_caps.streaming_support);
assert!(!default_caps.simd_analysis);
assert!(!default_caps.multi_memory);
assert_eq!(default_caps.max_file_size, 100 * 1024 * 1024);
let custom_caps = WasmAnalysisCapabilities {
memory_analysis: false,
gas_estimation: true,
security_analysis: true,
optimization_hints: false,
streaming_support: false,
simd_analysis: true,
multi_memory: true,
max_file_size: 200 * 1024 * 1024,
};
assert!(!custom_caps.memory_analysis);
assert!(custom_caps.simd_analysis);
assert_eq!(custom_caps.max_file_size, 200 * 1024 * 1024);
}
#[test]
fn test_security_integration() {
use crate::services::wasm::security::*;
use crate::services::wasm::types::Severity;
let validator = WasmSecurityValidator::new();
let valid_wasm = b"\0asm\x01\x00\x00\x00\x10\x00\x00\x00extra_data";
let result = validator.validate(valid_wasm).unwrap();
assert!(result.passed);
assert!(result.issues.is_empty());
let invalid_wasm = b"WASM\x01\x00\x00\x00";
let result = validator.validate(invalid_wasm).unwrap();
assert!(!result.passed);
assert!(!result.issues.is_empty());
assert_eq!(result.issues[0].severity, Severity::Critical);
assert_eq!(result.issues[0].category, SecurityCategory::InvalidFormat);
let tiny_wasm = b"\0a";
let result = validator.validate(tiny_wasm).unwrap();
assert!(!result.passed);
let mut large_wasm = vec![0, b'a', b's', b'm', 1, 0, 0, 0];
large_wasm.resize(101 * 1024 * 1024, 0);
let result = validator.validate(&large_wasm).unwrap();
assert!(!result.passed);
assert!(result.issues.iter().any(|i| {
i.severity == Severity::High && i.category == SecurityCategory::ResourceExhaustion
}));
let ast = crate::models::unified_ast::AstDag::new();
let result = validator.validate_ast(&ast);
assert!(result.is_ok());
let result = validator.validate_text("(module)");
assert!(result.is_ok());
let issue = SecurityIssue {
severity: Severity::Medium,
description: "Test security issue".to_string(),
category: SecurityCategory::MemorySafety,
};
assert_eq!(issue.severity, Severity::Medium);
assert_eq!(issue.description, "Test security issue");
let categories = vec![
SecurityCategory::InvalidFormat,
SecurityCategory::MemorySafety,
SecurityCategory::ResourceExhaustion,
SecurityCategory::CodeInjection,
SecurityCategory::Other,
];
for cat in categories {
let _ = format!("{:?}", cat);
}
}
#[test]
fn test_complexity_integration() {
use crate::models::unified_ast::{AstDag, AstKind, FunctionKind, Language, UnifiedAstNode};
use crate::services::wasm::complexity::*;
let default_model = MemoryCostModel::default();
assert_eq!(default_model.load_cost, 3.0);
assert_eq!(default_model.store_cost, 5.0);
assert_eq!(default_model.grow_cost, 100.0);
let custom_model = MemoryCostModel {
load_cost: 5.0,
store_cost: 10.0,
grow_cost: 150.0,
};
assert_eq!(custom_model.load_cost, 5.0);
let analyzer = WasmComplexityAnalyzer::new();
let ast = AstDag::new();
let result = analyzer.analyze_ast(&ast);
assert!(result.is_ok());
let complexity = result.unwrap();
assert_eq!(complexity.cyclomatic, 5);
let mut dag = AstDag::new();
let func_node = UnifiedAstNode::new(
AstKind::Function(FunctionKind::Regular),
Language::WebAssembly,
);
let func_id = dag.add_node(func_node);
let complexity = analyzer.analyze_function(&dag, func_id);
assert_eq!(complexity.cyclomatic, 1);
assert_eq!(complexity.cognitive, 1);
assert_eq!(complexity.max_loop_depth, 0);
let simple_module = "(module)";
let result = analyzer.analyze_text(simple_module);
assert!(result.is_ok());
let complex_module = r#"
(module
(func $add (param i32 i32) (result i32)
local.get 0
local.get 1
i32.add)
(func $sub (param i32 i32) (result i32)
local.get 0
local.get 1
i32.sub)
)"#;
let result = analyzer.analyze_text(complex_module);
assert!(result.is_ok());
let complexity = result.unwrap();
assert!(complexity.cyclomatic > 0);
}
}