use debtmap::complexity::cyclomatic::{
calculate_cyclomatic, calculate_cyclomatic_for_function, combine_cyclomatic,
};
use syn::{parse_quote, Block};
#[test]
fn test_calculate_cyclomatic_simple_block() {
let block: Block = parse_quote! {{
let x = 5;
let y = 10;
x + y
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 1,
"Simple block should have cyclomatic complexity of 1"
);
}
#[test]
fn test_calculate_cyclomatic_single_if() {
let block: Block = parse_quote! {{
if x > 0 {
println!("positive");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 2, "Single if statement adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_if_else() {
let block: Block = parse_quote! {{
if x > 0 {
println!("positive");
} else {
println!("non-positive");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 2,
"If-else adds 1 to complexity (for the decision point)"
);
}
#[test]
fn test_calculate_cyclomatic_nested_if() {
let block: Block = parse_quote! {{
if x > 0 {
if y > 0 {
println!("both positive");
}
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 3,
"Nested if statements each add 1 to complexity"
);
}
#[test]
fn test_calculate_cyclomatic_match_expression() {
let block: Block = parse_quote! {{
match value {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("other"),
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 4,
"Match with 4 arms adds 3 to complexity (n-1)"
);
}
#[test]
fn test_calculate_cyclomatic_match_with_guards() {
let block: Block = parse_quote! {{
match value {
x if x > 10 => println!("large"),
x if x > 5 => println!("medium"),
x if x > 0 => println!("small"),
_ => println!("non-positive"),
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 4,
"Match with 4 arms (including guards) adds 3 to complexity"
);
}
#[test]
fn test_calculate_cyclomatic_while_loop() {
let block: Block = parse_quote! {{
while x < 10 {
x += 1;
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 2, "While loop adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_for_loop() {
let block: Block = parse_quote! {{
for i in 0..10 {
println!("{}", i);
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 2, "For loop adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_loop() {
let block: Block = parse_quote! {{
loop {
if done {
break;
}
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 3, "Loop adds 1 and nested if adds 1");
}
#[test]
fn test_calculate_cyclomatic_logical_and() {
let block: Block = parse_quote! {{
if x > 0 && y > 0 {
println!("both positive");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 3,
"If with logical AND adds 2 to base (one for if, one for &&)"
);
}
#[test]
fn test_calculate_cyclomatic_logical_or() {
let block: Block = parse_quote! {{
if x > 0 || y > 0 {
println!("at least one positive");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 3,
"If with logical OR adds 2 to base (one for if, one for ||)"
);
}
#[test]
fn test_calculate_cyclomatic_multiple_logical_operators() {
let block: Block = parse_quote! {{
if (x > 0 && y > 0) || z < 0 {
println!("complex condition");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 4,
"If with multiple logical operators adds 3 to base (one for if, one for &&, one for ||)"
);
}
#[test]
fn test_calculate_cyclomatic_try_expression() {
let block: Block = parse_quote! {{
let result = operation()?;
result
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 2, "Try expression adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_multiple_try() {
let block: Block = parse_quote! {{
let a = operation1()?;
let b = operation2()?;
let c = operation3()?;
a + b + c
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 4, "Each try expression adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_linear_fallible_writer_pipeline() {
let block: Block = parse_quote! {{
write!(writer, "{}", header)?;
writeln!(writer)?;
write!(writer, "{}", body)?;
writeln!(writer)?;
write!(writer, "{}", footer)?;
writeln!(writer)?;
Ok(())
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 7,
"Linear fallible writer pipelines currently count each ? as one path"
);
}
#[test]
fn test_calculate_cyclomatic_optional_fallible_sections() {
let block: Block = parse_quote! {{
write!(writer, "{}", required)?;
if let Some(section) = optional_section {
write!(writer, "{}", section)?;
writeln!(writer)?;
}
Ok(())
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 5,
"Optional fallible sections count both the if and each ? expression"
);
}
#[test]
fn test_calculate_cyclomatic_try_inside_closure_excluded_from_parent() {
let block: Block = parse_quote! {{
let callback = || {
write!(writer, "{}", section)?;
writeln!(writer)?;
Ok(())
};
write!(writer, "{}", header)?;
callback
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 2,
"Parent cyclomatic excludes ? expressions inside closure bodies"
);
}
#[test]
fn test_calculate_cyclomatic_nested_match() {
let block: Block = parse_quote! {{
match outer {
Some(inner) => {
match inner {
1 => println!("one"),
2 => println!("two"),
_ => println!("other"),
}
}
None => println!("none"),
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 4,
"Outer match adds 1, inner match adds 2 (3 arms - 1)"
);
}
#[test]
fn test_calculate_cyclomatic_complex_control_flow() {
let block: Block = parse_quote! {{
for i in 0..10 {
if i % 2 == 0 {
continue;
}
match i {
1 | 3 | 5 => println!("small odd"),
7 | 9 => println!("large odd"),
_ => {}
}
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 5,
"For loop adds 1, if adds 1, match with 3 arms adds 2"
);
}
#[test]
fn test_calculate_cyclomatic_for_function_no_params() {
let base_complexity = 5;
let param_count = 0;
let result = calculate_cyclomatic_for_function(base_complexity, param_count);
assert_eq!(
result, 5,
"Function with no parameters doesn't add to complexity"
);
}
#[test]
fn test_calculate_cyclomatic_for_function_single_param() {
let base_complexity = 5;
let param_count = 1;
let result = calculate_cyclomatic_for_function(base_complexity, param_count);
assert_eq!(
result, 5,
"Function with one parameter doesn't add to complexity"
);
}
#[test]
fn test_calculate_cyclomatic_for_function_multiple_params() {
let base_complexity = 5;
let param_count = 3;
let result = calculate_cyclomatic_for_function(base_complexity, param_count);
assert_eq!(result, 7, "Function with 3 parameters adds 2 to complexity");
}
#[test]
fn test_calculate_cyclomatic_for_function_many_params() {
let base_complexity = 5;
let param_count = 10;
let result = calculate_cyclomatic_for_function(base_complexity, param_count);
assert_eq!(
result, 14,
"Function with 10 parameters adds 9 to complexity"
);
}
#[test]
fn test_combine_cyclomatic_empty() {
let branches = vec![];
assert_eq!(
combine_cyclomatic(branches),
1,
"Empty branches should return base complexity of 1"
);
}
#[test]
fn test_combine_cyclomatic_single_branch() {
let branches = vec![2];
assert_eq!(
combine_cyclomatic(branches),
3,
"Single branch adds to base complexity"
);
}
#[test]
fn test_combine_cyclomatic_multiple_branches() {
let branches = vec![2, 3, 4];
assert_eq!(
combine_cyclomatic(branches),
10,
"Multiple branches sum up plus 1"
);
}
#[test]
fn test_combine_cyclomatic_with_ones() {
let branches = vec![1, 1, 1, 1];
assert_eq!(
combine_cyclomatic(branches),
5,
"Four branches of complexity 1 sum to 5"
);
}
#[test]
fn test_calculate_cyclomatic_else_if_chain() {
let block: Block = parse_quote! {{
if x > 10 {
println!("greater than 10");
} else if x > 5 {
println!("greater than 5");
} else if x > 0 {
println!("greater than 0");
} else {
println!("non-positive");
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(
complexity, 4,
"Else-if chain: 1 base + 3 conditions (if, else-if, else-if)"
);
}
#[test]
fn test_calculate_cyclomatic_early_return() {
let block: Block = parse_quote! {{
if error {
return Err("error");
}
if warning {
return Ok(0);
}
Ok(42)
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 3, "Each if statement adds 1 to complexity");
}
#[test]
fn test_calculate_cyclomatic_break_continue() {
let block: Block = parse_quote! {{
for i in 0..10 {
if i == 5 {
break;
}
if i % 2 == 0 {
continue;
}
println!("{}", i);
}
}};
let complexity = calculate_cyclomatic(&block);
assert_eq!(complexity, 4, "For loop adds 1, each if statement adds 1");
}