println!("=== Binary Ninja Comparison Test ===\n");

// Create client

let client = BinaryNinjaClient::new();

// Step 1: Discover servers

println!("Step 1: Discovering Binary Ninja servers...");

let servers = client.discover_servers().await?;

if servers.is_empty() {

println!("✗ No Binary Ninja servers found!");

println!(" Make sure Binary Ninja is running with binaries loaded");

println!(" Use 'MCP Server > Start Server for This Binary' in Binary Ninja");

return Ok(());

}

println!("✓ Found {} server(s):", servers.len());

for server in &servers {

println!(" - {}: {} (port {})", server.binary_id, server.filename, server.port);

}

println!();

if servers.len() < 2 {

println!("⚠ Need at least 2 binaries to test comparison");

println!(" Load another binary in Binary Ninja and start its server");

return Ok(());

}

// Step 2: Get function lists from both binaries

let binary_a = &servers[0];

let binary_b = &servers[1];

println!("Step 2: Comparing binaries:");

println!(" Binary A: {} ({})", binary_a.filename, binary_a.binary_id);

println!(" Binary B: {} ({})", binary_b.filename, binary_b.binary_id);

println!();

println!("Step 3: Fetching function lists...");

let functions_a_raw = client.list_functions(&binary_a.binary_id).await?;

let functions_b_raw = client.list_functions(&binary_b.binary_id).await?;

println!(" Binary A: {} functions", functions_a_raw.len());

println!(" Binary B: {} functions", functions_b_raw.len());

println!();

// Convert to BinaryFunctionInfo

let functions_a: Vec<BinaryFunctionInfo> = functions_a_raw

.into_iter()

.map(|f| BinaryFunctionInfo::new(f.name, f.address))

.collect();

let functions_b: Vec<BinaryFunctionInfo> = functions_b_raw

.into_iter()

.map(|f| BinaryFunctionInfo::new(f.name, f.address))

.collect();

// Step 4: Perform matching

println!("Step 4: Matching functions...");

let matcher = BinaryFunctionMatcher::new();

let matches = matcher.match_functions(&functions_a, &functions_b)?;

println!("✓ Found {} matches", matches.len());

println!();

// Step 5: Show statistics

println!("Step 5: Match Statistics:");

let exact_matches = matches.iter().filter(|m| m.name_similarity == 1.0).count();

let fuzzy_matches = matches.iter().filter(|m| m.name_similarity < 1.0).count();

let avg_similarity: f64 = matches.iter().map(|m| m.similarity).sum::<f64>() / matches.len() as f64;

println!(" Exact name matches: {}", exact_matches);

println!(" Fuzzy name matches: {}", fuzzy_matches);

println!(" Average similarity: {:.1}%", avg_similarity * 100.0);

println!();

// Step 6: Show top 10 most changed functions

println!("Step 6: Top 10 Most Changed Functions:");

let mut sorted_matches = matches.clone();

sorted_matches.sort_by(|a, b| a.similarity.partial_cmp(&b.similarity).unwrap());

for (i, m) in sorted_matches.iter().take(10).enumerate() {

println!(

" {}. {} <-> {} (similarity: {:.1}%, type: {:?})",

i + 1,

m.function_a.name,

m.function_b.name,

m.similarity * 100.0,

m.match_type

);

}

println!();

// Step 7: Test decompilation for first match

if let Some(first_match) = sorted_matches.first() {

println!("Step 7: Testing decompilation for most changed function:");

println!(" Function: {} <-> {}", first_match.function_a.name, first_match.function_b.name);

println!();

println!(" Decompiling from Binary A...");

match client.decompile_function(&binary_a.binary_id, &first_match.function_a.name).await {

Ok(code) => {

println!(" ✓ Decompiled ({} bytes)", code.len());

let lines: Vec<&str> = code.lines().take(10).collect();

for line in lines {

println!(" {}", line);

}

if code.lines().count() > 10 {

println!(" ... ({} more lines)", code.lines().count() - 10);

}

}

Err(e) => println!(" ✗ Failed: {}", e),

}

println!();

println!(" Decompiling from Binary B...");

match client.decompile_function(&binary_b.binary_id, &first_match.function_b.name).await {

Ok(code) => {

println!(" ✓ Decompiled ({} bytes)", code.len());

let lines: Vec<&str> = code.lines().take(10).collect();

for line in lines {

println!(" {}", line);

}

if code.lines().count() > 10 {

println!(" ... ({} more lines)", code.lines().count() - 10);

}

}

Err(e) => println!(" ✗ Failed: {}", e),

}

}

println!();

println!("=== Test Complete ===");

println!("✓ Binary comparison functionality is working!");

Ok(())