#[test]
fn test_real_profile_results_synthetic_data() {
let results = RealProfileResults {
model_path: "synthetic.gguf".to_string(),
architecture: "mock".to_string(),
num_layers: 4,
vocab_size: 1000,
hidden_dim: 256,
warmup_passes: 1,
measure_passes: 1,
total_inference_us: 1000.0,
throughput_tok_s: 1000.0,
tokens_per_pass: 1,
hotspots: vec![],
per_layer_us: vec![],
is_real_data: false,
roofline: None,
category_summary: None,
backend: "cpu".to_string(),
..Default::default()
};
assert!(!results.is_real_data);
}
#[test]
fn test_detect_format_apr_path() {
let path = Path::new("/some/deep/path/model.apr");
assert_eq!(detect_format(path), "apr");
}
#[test]
fn test_detect_format_safetensors_path() {
let path = Path::new("models/v1.0/model.safetensors");
assert_eq!(detect_format(path), "safetensors");
}
#[test]
fn test_detect_format_gguf_with_version() {
let path = Path::new("qwen2.5-coder-1.5b-q4_k_m.gguf");
assert_eq!(detect_format(path), "gguf");
}
#[test]
fn test_detect_format_empty_extension() {
let path = Path::new("model.");
assert_eq!(detect_format(path), "unknown");
}
#[test]
fn test_ci_assertions_all_set() {
let assertions = CiAssertions {
min_throughput: Some(100.0),
max_p99_ms: Some(50.0),
max_p50_ms: Some(25.0),
max_memory_mb: Some(1024.0),
};
assert!(assertions.min_throughput.is_some());
assert!(assertions.max_p99_ms.is_some());
assert!(assertions.max_p50_ms.is_some());
}
#[test]
fn test_ci_profile_report_multiple_assertions_fail() {
let results = RealProfileResults {
model_path: "model.gguf".to_string(),
architecture: "llama".to_string(),
num_layers: 32,
vocab_size: 32000,
hidden_dim: 4096,
warmup_passes: 3,
measure_passes: 10,
total_inference_us: 100000.0, throughput_tok_s: 10.0, tokens_per_pass: 10,
hotspots: vec![],
per_layer_us: vec![],
is_real_data: true,
roofline: None,
category_summary: None,
backend: "cpu".to_string(),
..Default::default()
};
let assertions = CiAssertions {
min_throughput: Some(100.0), max_p99_ms: Some(50.0), ..Default::default()
};
let report = CiProfileReport::from_results(&results, &assertions);
assert!(!report.passed);
assert_eq!(report.assertions.iter().filter(|a| !a.passed).count(), 2);
}
#[test]
fn test_ci_profile_report_boundary_values() {
let results = RealProfileResults {
model_path: "model.gguf".to_string(),
architecture: "llama".to_string(),
num_layers: 32,
vocab_size: 32000,
hidden_dim: 4096,
warmup_passes: 3,
measure_passes: 10,
total_inference_us: 50000.0, throughput_tok_s: 100.0, tokens_per_pass: 10,
hotspots: vec![],
per_layer_us: vec![],
is_real_data: true,
roofline: None,
category_summary: None,
backend: "cpu".to_string(),
..Default::default()
};
let assertions = CiAssertions {
min_throughput: Some(100.0), max_p99_ms: Some(50.0), ..Default::default()
};
let report = CiProfileReport::from_results(&results, &assertions);
assert!(report.passed);
}
#[test]
fn test_output_format_copy_trait() {
let format = OutputFormat::Json;
let copied = format;
assert!(matches!(format, OutputFormat::Json));
assert!(matches!(copied, OutputFormat::Json));
}
#[test]
fn test_profile_focus_copy_trait() {
let focus = ProfileFocus::Mlp;
let copied = focus;
assert!(matches!(focus, ProfileFocus::Mlp));
assert!(matches!(copied, ProfileFocus::Mlp));
}
#[test]
fn test_output_format_parse_mixed_case() {
assert!(matches!(
"Json".parse::<OutputFormat>().expect("parse::<OutputFormat>("),
OutputFormat::Json
));
assert!(matches!(
"FLAMEGRAPH".parse::<OutputFormat>().expect("parse::<OutputFormat>("),
OutputFormat::Flamegraph
));
}
#[test]
fn test_profile_focus_parse_mixed_case() {
assert!(matches!(
"ATTENTION".parse::<ProfileFocus>().expect("parse::<ProfileFocus>("),
ProfileFocus::Attention
));
assert!(matches!(
"Mlp".parse::<ProfileFocus>().expect("parse::<ProfileFocus>("),
ProfileFocus::Mlp
));
}
fn make_test_results_with_hotspots() -> RealProfileResults {
RealProfileResults {
model_path: "test.gguf".to_string(),
architecture: "llama".to_string(),
num_layers: 32,
vocab_size: 32000,
hidden_dim: 4096,
warmup_passes: 3,
measure_passes: 10,
total_inference_us: 10000.0,
throughput_tok_s: 100.0,
tokens_per_pass: 10,
hotspots: vec![
Hotspot {
name: "attention_qkv".to_string(),
time_us: 3000.0,
percent: 30.0,
count: 10,
avg_us: 300.0,
min_us: 280.0,
max_us: 320.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "mlp_gate_up".to_string(),
time_us: 2500.0,
percent: 25.0,
count: 10,
avg_us: 250.0,
min_us: 230.0,
max_us: 270.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "matmul_q4k".to_string(),
time_us: 2000.0,
percent: 20.0,
count: 10,
avg_us: 200.0,
min_us: 180.0,
max_us: 220.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "embedding_lookup".to_string(),
time_us: 1000.0,
percent: 10.0,
count: 10,
avg_us: 100.0,
min_us: 90.0,
max_us: 110.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "softmax".to_string(),
time_us: 800.0,
percent: 8.0,
count: 10,
avg_us: 80.0,
min_us: 70.0,
max_us: 90.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "ffn_down_proj".to_string(),
time_us: 500.0,
percent: 5.0,
count: 10,
avg_us: 50.0,
min_us: 40.0,
max_us: 60.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "lm_head".to_string(),
time_us: 200.0,
percent: 2.0,
count: 10,
avg_us: 20.0,
min_us: 15.0,
max_us: 25.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "linear_proj".to_string(),
time_us: 100.0,
percent: 1.0,
count: 10,
avg_us: 10.0,
min_us: 8.0,
max_us: 12.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
Hotspot {
name: "gemm_f16".to_string(),
time_us: 50.0,
percent: 0.5,
count: 5,
avg_us: 10.0,
min_us: 8.0,
max_us: 12.0,
bottleneck: None,
efficiency_pct: None,
category: None,
bandwidth_gbs: None,
data_bytes_per_call: None,
},
],
per_layer_us: vec![312.5; 32],
is_real_data: true,
roofline: None,
category_summary: None,
backend: "cpu".to_string(),
..Default::default()
}
}
#[test]
fn test_filter_results_by_focus_all() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::All);
assert_eq!(filtered.hotspots.len(), results.hotspots.len());
}
#[test]
fn test_filter_results_by_focus_attention() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::Attention);
assert_eq!(
filtered.hotspots.len(),
2,
"Expected 2 attention hotspots, got names: {:?}",
filtered
.hotspots
.iter()
.map(|h| &h.name)
.collect::<Vec<_>>()
);
assert!(filtered.hotspots.iter().any(|h| h.name == "attention_qkv"));
assert!(filtered.hotspots.iter().any(|h| h.name == "softmax"));
}
#[test]
fn test_filter_results_by_focus_mlp() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::Mlp);
assert!(
filtered.hotspots.len() >= 2,
"Expected at least 2 MLP hotspots, got names: {:?}",
filtered
.hotspots
.iter()
.map(|h| &h.name)
.collect::<Vec<_>>()
);
assert!(filtered.hotspots.iter().any(|h| h.name == "mlp_gate_up"));
assert!(filtered.hotspots.iter().any(|h| h.name == "ffn_down_proj"));
}
#[test]
fn test_filter_results_by_focus_matmul() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::Matmul);
assert!(
filtered.hotspots.len() >= 3,
"Expected at least 3 matmul hotspots, got names: {:?}",
filtered
.hotspots
.iter()
.map(|h| &h.name)
.collect::<Vec<_>>()
);
assert!(filtered.hotspots.iter().any(|h| h.name == "matmul_q4k"));
assert!(filtered.hotspots.iter().any(|h| h.name == "linear_proj"));
assert!(filtered.hotspots.iter().any(|h| h.name == "gemm_f16"));
}
#[test]
fn test_filter_results_by_focus_embedding() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::Embedding);
assert_eq!(
filtered.hotspots.len(),
2,
"Expected 2 embedding hotspots, got names: {:?}",
filtered
.hotspots
.iter()
.map(|h| &h.name)
.collect::<Vec<_>>()
);
assert!(filtered
.hotspots
.iter()
.any(|h| h.name == "embedding_lookup"));
assert!(filtered.hotspots.iter().any(|h| h.name == "lm_head"));
}
#[test]
fn test_filter_results_preserves_metadata() {
let results = make_test_results_with_hotspots();
let filtered = filter_results_by_focus(&results, ProfileFocus::Attention);
assert_eq!(filtered.model_path, results.model_path);
assert_eq!(filtered.architecture, results.architecture);
assert_eq!(filtered.num_layers, results.num_layers);
assert_eq!(filtered.vocab_size, results.vocab_size);
assert_eq!(filtered.hidden_dim, results.hidden_dim);
assert_eq!(filtered.warmup_passes, results.warmup_passes);
assert_eq!(filtered.measure_passes, results.measure_passes);
assert_eq!(filtered.total_inference_us, results.total_inference_us);
assert_eq!(filtered.throughput_tok_s, results.throughput_tok_s);
assert_eq!(filtered.tokens_per_pass, results.tokens_per_pass);
assert_eq!(filtered.per_layer_us.len(), results.per_layer_us.len());
assert_eq!(filtered.is_real_data, results.is_real_data);
}