{
"test_cases": [
{
"id": "file_io_read_config",
"function_name": "read_config_file",
"language": "rust",
"code": "fn read_config_file(path: &Path) -> Result<Config> {\n let contents = fs::read_to_string(path)?;\n toml::from_str(&contents)\n}",
"expected_category": "FileIO",
"minimum_confidence": 0.70,
"rationale": "Direct file system operations with Path parameter"
},
{
"id": "pure_calculation",
"function_name": "calculate_total",
"language": "rust",
"code": "fn calculate_total(items: &[Item]) -> f64 {\n items.iter().map(|i| i.price * i.quantity).sum()\n}",
"expected_category": "PureComputation",
"minimum_confidence": 0.75,
"rationale": "Pure mathematical computation with no side effects"
},
{
"id": "http_handler_axum",
"function_name": "handle_get_user",
"language": "rust",
"code": "async fn handle_get_user(\n Path(user_id): Path<u64>,\n State(db): State<Database>,\n) -> Result<Json<User>, StatusCode> {\n let user = db.get_user(user_id).await?;\n Ok(Json(user))\n}",
"expected_category": "HttpRequestHandler",
"minimum_confidence": 0.85,
"rationale": "Axum web handler with Path extractor and async"
},
{
"id": "database_query",
"function_name": "find_user_by_email",
"language": "rust",
"code": "async fn find_user_by_email(email: &str, pool: &PgPool) -> Result<User> {\n sqlx::query_as!(User, \"SELECT * FROM users WHERE email = $1\", email)\n .fetch_one(pool)\n .await\n}",
"expected_category": "DatabaseIO",
"minimum_confidence": 0.80,
"rationale": "SQL query with database connection pool"
},
{
"id": "validation_function",
"function_name": "validate_email",
"language": "rust",
"code": "fn validate_email(email: &str) -> bool {\n let re = Regex::new(r\"^[^@]+@[^@]+\\.[^@]+$\").unwrap();\n re.is_match(email)\n}",
"expected_category": "Validation",
"minimum_confidence": 0.70,
"rationale": "Validates input using regex pattern matching"
},
{
"id": "transformation_map",
"function_name": "transform_user_dto",
"language": "rust",
"code": "fn transform_user_dto(user: User) -> UserDTO {\n UserDTO {\n id: user.id,\n name: format!(\"{} {}\", user.first_name, user.last_name),\n email: user.email,\n }\n}",
"expected_category": "Transformation",
"minimum_confidence": 0.75,
"rationale": "Transforms data from one structure to another"
},
{
"id": "parsing_json",
"function_name": "parse_request_body",
"language": "rust",
"code": "fn parse_request_body(body: &str) -> Result<Request> {\n serde_json::from_str(body)\n .context(\"Failed to parse request body\")\n}",
"expected_category": "Parsing",
"minimum_confidence": 0.80,
"rationale": "Parses JSON string into structured data"
},
{
"id": "formatting_output",
"function_name": "format_report",
"language": "rust",
"code": "fn format_report(data: &ReportData) -> String {\n format!(\n \"Report for {}:\\n Total: {}\\n Status: {}\",\n data.name, data.total, data.status\n )\n}",
"expected_category": "Formatting",
"minimum_confidence": 0.75,
"rationale": "Formats data into human-readable string"
},
{
"id": "orchestration_workflow",
"function_name": "process_order",
"language": "rust",
"code": "async fn process_order(order: Order) -> Result<()> {\n validate_order(&order)?;\n let payment = charge_payment(&order).await?;\n update_inventory(&order).await?;\n send_confirmation(&order).await?;\n notify_warehouse(&order).await?;\n Ok(())\n}",
"expected_category": "Orchestration",
"minimum_confidence": 0.80,
"rationale": "Orchestrates multiple operations in sequence"
},
{
"id": "network_io_http_request",
"function_name": "fetch_user_data",
"language": "rust",
"code": "async fn fetch_user_data(user_id: u64) -> Result<UserData> {\n let url = format!(\"https://api.example.com/users/{}\", user_id);\n let response = reqwest::get(&url).await?;\n response.json::<UserData>().await\n}",
"expected_category": "NetworkIO",
"minimum_confidence": 0.85,
"rationale": "HTTP request to external API"
},
{
"id": "test_function",
"function_name": "test_user_creation",
"language": "rust",
"code": "#[test]\nfn test_user_creation() {\n let user = User::new(\"test@example.com\");\n assert_eq!(user.email, \"test@example.com\");\n assert!(user.id > 0);\n}",
"expected_category": "TestFunction",
"minimum_confidence": 0.95,
"rationale": "Test function with #[test] attribute"
},
{
"id": "error_handling",
"function_name": "handle_request_error",
"language": "rust",
"code": "fn handle_request_error(error: RequestError) -> AppError {\n match error {\n RequestError::InvalidInput(msg) => AppError::BadRequest(msg),\n RequestError::Unauthorized => AppError::Unauthorized,\n _ => AppError::Unknown,\n }\n}",
"expected_category": "ErrorHandling",
"minimum_confidence": 0.75,
"rationale": "Converts request errors to application errors"
},
{
"id": "cli_handler",
"function_name": "handle_cli_command",
"language": "rust",
"code": "fn handle_cli_command(args: InitArgs) -> Result<()> {\n println!(\"Initializing project in: {}\", args.path);\n create_directory_structure(&args.path)?;\n write_default_config(&args.path)?;\n println!(\"Project initialized successfully!\");\n Ok(())\n}",
"expected_category": "CliHandler",
"minimum_confidence": 0.80,
"rationale": "Handles CLI command with console output"
},
{
"id": "configuration_io",
"function_name": "load_config",
"language": "rust",
"code": "fn load_config() -> Result<AppConfig> {\n let config_path = env::var(\"APP_CONFIG\").unwrap_or_else(|_| \"config.toml\".to_string());\n let contents = fs::read_to_string(&config_path)?;\n toml::from_str(&contents)\n}",
"expected_category": "ConfigurationIO",
"minimum_confidence": 0.75,
"rationale": "Loads configuration from file and environment"
},
{
"id": "coordination_delegator",
"function_name": "delegate_task",
"language": "rust",
"code": "async fn delegate_task(task: Task, workers: &WorkerPool) -> Result<()> {\n let worker = workers.find_available().await?;\n worker.assign(task).await?;\n monitor_progress(&task).await\n}",
"expected_category": "Coordination",
"minimum_confidence": 0.70,
"rationale": "Coordinates task delegation between components"
}
]
}