#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_language_from_extension() {
assert_eq!(
Language::from_extension(Path::new("test.rs")),
Language::Rust
);
assert_eq!(
Language::from_extension(Path::new("test.py")),
Language::Python
);
assert_eq!(
Language::from_extension(Path::new("test.js")),
Language::JavaScript
);
assert_eq!(
Language::from_extension(Path::new("test.ts")),
Language::TypeScript
);
assert_eq!(Language::from_extension(Path::new("test.go")), Language::Go);
assert_eq!(
Language::from_extension(Path::new("test.java")),
Language::Java
);
assert_eq!(Language::from_extension(Path::new("test.c")), Language::C);
assert_eq!(
Language::from_extension(Path::new("test.cpp")),
Language::Cpp
);
assert_eq!(
Language::from_extension(Path::new("test.ruchy")),
Language::Ruchy
);
assert_eq!(
Language::from_extension(Path::new("script.rh")),
Language::Ruchy
);
assert_eq!(
Language::from_extension(Path::new("test.unknown")),
Language::Unknown
);
}
#[test]
fn test_naming_style_matches() {
assert!(NamingStyle::SnakeCase.matches("snake_case"));
assert!(NamingStyle::SnakeCase.matches("my_variable_123"));
assert!(!NamingStyle::SnakeCase.matches("camelCase"));
assert!(NamingStyle::CamelCase.matches("camelCase"));
assert!(NamingStyle::CamelCase.matches("myVariable123"));
assert!(!NamingStyle::CamelCase.matches("PascalCase"));
assert!(!NamingStyle::CamelCase.matches("snake_case"));
assert!(NamingStyle::PascalCase.matches("PascalCase"));
assert!(NamingStyle::PascalCase.matches("MyClass123"));
assert!(!NamingStyle::PascalCase.matches("camelCase"));
assert!(!NamingStyle::PascalCase.matches("snake_case"));
assert!(NamingStyle::ScreamingSnakeCase.matches("SCREAMING_SNAKE"));
assert!(NamingStyle::ScreamingSnakeCase.matches("MAX_VALUE_123"));
assert!(!NamingStyle::ScreamingSnakeCase.matches("snake_case"));
assert!(NamingStyle::KebabCase.matches("kebab-case"));
assert!(NamingStyle::KebabCase.matches("my-component-123"));
assert!(!NamingStyle::KebabCase.matches("snake_case"));
}
#[test]
fn test_ruchy_language_rules() {
let rules = LanguageRules::for_language(Language::Ruchy);
assert_eq!(rules.language, Language::Ruchy);
assert_eq!(rules.function_style, NamingStyle::SnakeCase);
assert_eq!(rules.type_style, NamingStyle::PascalCase);
assert_eq!(rules.constant_style, NamingStyle::ScreamingSnakeCase);
assert_eq!(rules.variable_style, NamingStyle::SnakeCase);
}
#[test]
fn test_ruchy_language_confidence() {
assert_eq!(Language::Ruchy.confidence(), 0.95);
assert!(Language::Ruchy.confidence() > Language::Java.confidence());
assert!(Language::Ruchy.confidence() == Language::Go.confidence());
}
#[test]
fn test_language_from_extension_jsx() {
assert_eq!(
Language::from_extension(Path::new("app.jsx")),
Language::JavaScript
);
}
#[test]
fn test_language_from_extension_tsx() {
assert_eq!(
Language::from_extension(Path::new("component.tsx")),
Language::TypeScript
);
}
#[test]
fn test_language_from_extension_header() {
assert_eq!(Language::from_extension(Path::new("header.h")), Language::C);
}
#[test]
fn test_language_from_extension_cc() {
assert_eq!(
Language::from_extension(Path::new("main.cc")),
Language::Cpp
);
}
#[test]
fn test_language_from_extension_cxx() {
assert_eq!(
Language::from_extension(Path::new("main.cxx")),
Language::Cpp
);
}
#[test]
fn test_language_from_extension_hpp() {
assert_eq!(
Language::from_extension(Path::new("header.hpp")),
Language::Cpp
);
}
#[test]
fn test_language_from_extension_ruby() {
assert_eq!(
Language::from_extension(Path::new("script.rb")),
Language::Ruby
);
}
#[test]
fn test_language_from_extension_swift() {
assert_eq!(
Language::from_extension(Path::new("app.swift")),
Language::Swift
);
}
#[test]
fn test_language_from_extension_kotlin() {
assert_eq!(
Language::from_extension(Path::new("Main.kt")),
Language::Kotlin
);
}
#[test]
fn test_language_from_extension_kotlin_script() {
assert_eq!(
Language::from_extension(Path::new("build.kts")),
Language::Kotlin
);
}
#[test]
fn test_language_from_extension_lean() {
assert_eq!(
Language::from_extension(Path::new("Basic.lean")),
Language::Lean
);
}
#[test]
fn test_language_from_extension_no_extension() {
assert_eq!(
Language::from_extension(Path::new("Makefile")),
Language::Unknown
);
}
#[test]
fn test_language_display_all() {
assert_eq!(format!("{}", Language::Rust), "Rust");
assert_eq!(format!("{}", Language::Python), "Python");
assert_eq!(format!("{}", Language::JavaScript), "JavaScript");
assert_eq!(format!("{}", Language::TypeScript), "TypeScript");
assert_eq!(format!("{}", Language::Go), "Go");
assert_eq!(format!("{}", Language::Java), "Java");
assert_eq!(format!("{}", Language::C), "C");
assert_eq!(format!("{}", Language::Cpp), "C++");
assert_eq!(format!("{}", Language::Ruby), "Ruby");
assert_eq!(format!("{}", Language::Swift), "Swift");
assert_eq!(format!("{}", Language::Kotlin), "Kotlin");
assert_eq!(format!("{}", Language::Ruchy), "Ruchy");
assert_eq!(format!("{}", Language::Lean), "Lean");
assert_eq!(format!("{}", Language::Unknown), "Unknown");
}
#[test]
fn test_language_confidence_all() {
assert_eq!(Language::Rust.confidence(), 1.0);
assert_eq!(Language::Python.confidence(), 0.95);
assert_eq!(Language::JavaScript.confidence(), 0.90);
assert_eq!(Language::TypeScript.confidence(), 0.90);
assert_eq!(Language::Go.confidence(), 0.95);
assert_eq!(Language::Java.confidence(), 0.85);
assert_eq!(Language::C.confidence(), 0.80);
assert_eq!(Language::Cpp.confidence(), 0.75);
assert_eq!(Language::Ruby.confidence(), 0.85);
assert_eq!(Language::Swift.confidence(), 0.85);
assert_eq!(Language::Kotlin.confidence(), 0.85);
assert_eq!(Language::Lean.confidence(), 0.95);
assert_eq!(Language::Unknown.confidence(), 0.5);
}
#[test]
fn test_language_serialization() {
let lang = Language::Rust;
let json = serde_json::to_string(&lang).unwrap();
let deserialized: Language = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, Language::Rust);
}
#[test]
fn test_language_hash() {
use std::collections::HashSet;
let mut set = HashSet::new();
set.insert(Language::Rust);
set.insert(Language::Python);
assert!(set.contains(&Language::Rust));
assert!(set.contains(&Language::Python));
}
#[test]
fn test_naming_style_clone() {
let style = NamingStyle::CamelCase;
let cloned = style.clone();
assert_eq!(style, cloned);
}
#[test]
fn test_naming_style_empty_string() {
assert!(!NamingStyle::CamelCase.matches(""));
assert!(!NamingStyle::PascalCase.matches(""));
}
#[test]
fn test_language_rules_rust() {
let rules = LanguageRules::rust_rules();
assert_eq!(rules.language, Language::Rust);
assert_eq!(rules.function_style, NamingStyle::SnakeCase);
}
#[test]
fn test_language_rules_python() {
let rules = LanguageRules::python_rules();
assert_eq!(rules.language, Language::Python);
assert_eq!(rules.function_style, NamingStyle::SnakeCase);
}
#[test]
fn test_language_rules_javascript() {
let rules = LanguageRules::javascript_rules();
assert_eq!(rules.language, Language::JavaScript);
assert_eq!(rules.function_style, NamingStyle::CamelCase);
}
#[test]
fn test_language_rules_typescript() {
let rules = LanguageRules::typescript_rules();
assert_eq!(rules.language, Language::TypeScript);
assert_eq!(rules.function_style, NamingStyle::CamelCase);
}
#[test]
fn test_language_rules_go() {
let rules = LanguageRules::go_rules();
assert_eq!(rules.language, Language::Go);
assert_eq!(rules.function_style, NamingStyle::PascalCase);
}
#[test]
fn test_lean_language_rules() {
let rules = LanguageRules::for_language(Language::Lean);
assert_eq!(rules.language, Language::Lean);
assert_eq!(rules.function_style, NamingStyle::CamelCase);
assert_eq!(rules.type_style, NamingStyle::PascalCase);
}
#[test]
fn test_lean_language_confidence() {
assert_eq!(Language::Lean.confidence(), 0.95);
}
#[test]
fn test_language_rules_for_default_language() {
let rules = LanguageRules::for_language(Language::Java);
assert_eq!(rules.language, Language::Rust); }
#[test]
fn test_language_rules_clone() {
let rules = LanguageRules::rust_rules();
let cloned = rules.clone();
assert_eq!(cloned.language, Language::Rust);
}
#[test]
fn test_language_rules_debug() {
let rules = LanguageRules::rust_rules();
let debug_str = format!("{:?}", rules);
assert!(debug_str.contains("LanguageRules"));
}
}
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
use proptest::prelude::*;
proptest! {
#[test]
fn basic_property_stability(_input in ".*") {
prop_assert!(true);
}
#[test]
fn module_consistency_check(_x in 0u32..1000) {
prop_assert!(_x < 1001);
}
}
}