#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
use std::path::PathBuf;
#[test]
fn test_language_count() {
let registry = LanguageRegistry::new();
assert!(
registry.language_count() >= 50,
"Should support 50+ languages"
);
}
#[test]
fn test_language_detection() {
assert_eq!(Language::from_extension("rs"), Language::Rust);
assert_eq!(Language::from_extension("py"), Language::Python);
assert_eq!(Language::from_extension("js"), Language::JavaScript);
assert_eq!(Language::from_extension("ts"), Language::TypeScript);
assert_eq!(Language::from_extension("go"), Language::Go);
assert_eq!(Language::from_extension("java"), Language::Java);
assert_eq!(Language::from_extension("cpp"), Language::Cpp);
assert_eq!(Language::from_extension("kt"), Language::Kotlin);
assert_eq!(Language::from_extension("swift"), Language::Swift);
assert_eq!(Language::from_extension("rb"), Language::Ruby);
}
#[test]
fn test_path_detection() {
assert_eq!(
Language::from_path(&PathBuf::from("src/main.rs")),
Language::Rust
);
assert_eq!(
Language::from_path(&PathBuf::from("app.py")),
Language::Python
);
assert_eq!(
Language::from_path(&PathBuf::from("index.js")),
Language::JavaScript
);
assert_eq!(
Language::from_path(&PathBuf::from("component.tsx")),
Language::TypeScript
);
assert_eq!(
Language::from_path(&PathBuf::from("Makefile")),
Language::Makefile
);
assert_eq!(
Language::from_path(&PathBuf::from("package.json")),
Language::JSON
);
assert_eq!(
Language::from_path(&PathBuf::from("docker-compose.yml")),
Language::YAML
);
}
#[test]
fn test_ast_support() {
assert!(Language::Rust.has_ast_support());
assert!(Language::Python.has_ast_support());
assert!(Language::TypeScript.has_ast_support());
assert!(Language::JSON.has_ast_support());
assert!(!Language::Unknown.has_ast_support());
}
#[test]
fn test_complexity_support() {
assert!(Language::Rust.supports_complexity());
assert!(Language::Python.supports_complexity());
assert!(Language::Java.supports_complexity());
assert!(!Language::JSON.supports_complexity());
assert!(!Language::Markdown.supports_complexity());
}
#[test]
fn test_language_names() {
assert_eq!(Language::Rust.name(), "Rust");
assert_eq!(Language::TypeScript.name(), "TypeScript");
assert_eq!(Language::CSharp.name(), "C#");
assert_eq!(Language::Cpp.name(), "C++");
assert_eq!(Language::ObjectiveC.name(), "Objective-C");
}
#[test]
fn test_language_extensions() {
assert!(Language::Rust.extensions().contains(&"rs"));
assert!(Language::Python.extensions().contains(&"py"));
assert!(Language::Python.extensions().contains(&"pyw"));
assert!(Language::TypeScript.extensions().contains(&"ts"));
assert!(Language::TypeScript.extensions().contains(&"tsx"));
assert!(Language::JavaScript.extensions().contains(&"js"));
assert!(Language::JavaScript.extensions().contains(&"jsx"));
assert!(Language::Unknown.extensions().is_empty());
}
#[test]
fn test_special_filename_detection() {
assert_eq!(
Language::from_path(&PathBuf::from("Makefile")),
Language::Makefile
);
assert_eq!(
Language::from_path(&PathBuf::from("GNUmakefile")),
Language::Makefile
);
assert_eq!(
Language::from_path(&PathBuf::from("Dockerfile")),
Language::Bash
);
assert_eq!(
Language::from_path(&PathBuf::from("Dockerfile.dev")),
Language::Bash
);
assert_eq!(
Language::from_path(&PathBuf::from("Rakefile")),
Language::Ruby
);
assert_eq!(
Language::from_path(&PathBuf::from("Gemfile")),
Language::Ruby
);
assert_eq!(
Language::from_path(&PathBuf::from("Gemfile.lock")),
Language::Ruby
);
assert_eq!(
Language::from_path(&PathBuf::from("Cargo.toml")),
Language::TOML
);
assert_eq!(
Language::from_path(&PathBuf::from("Cargo.lock")),
Language::TOML
);
assert_eq!(
Language::from_path(&PathBuf::from("package.json")),
Language::JSON
);
assert_eq!(
Language::from_path(&PathBuf::from("tsconfig.json")),
Language::JSON
);
assert_eq!(
Language::from_path(&PathBuf::from("build.gradle")),
Language::Gradle
);
assert_eq!(
Language::from_path(&PathBuf::from("settings.gradle")),
Language::Gradle
);
assert_eq!(
Language::from_path(&PathBuf::from("pom.xml")),
Language::Maven
);
assert_eq!(
Language::from_path(&PathBuf::from("requirements.txt")),
Language::Python
);
assert_eq!(
Language::from_path(&PathBuf::from("setup.py")),
Language::Python
);
assert_eq!(
Language::from_path(&PathBuf::from("pyproject.toml")),
Language::Python
);
}
#[test]
fn test_language_registry_methods() {
let registry = LanguageRegistry::new();
let languages = registry.supported_languages();
assert!(languages.len() >= 50);
assert_eq!(
registry.detect_language(&PathBuf::from("test.rs")),
Language::Rust
);
let ast_langs = registry.ast_supported_languages();
assert!(ast_langs.contains(&Language::Rust));
assert!(ast_langs.contains(&Language::Python));
assert!(ast_langs.contains(&Language::TypeScript));
let complexity_langs = registry.complexity_supported_languages();
assert!(complexity_langs.contains(&Language::Rust));
assert!(complexity_langs.contains(&Language::Python));
assert!(!complexity_langs.contains(&Language::JSON));
}
#[test]
fn test_language_registry_default() {
let registry = LanguageRegistry::default();
assert!(registry.language_count() >= 50);
}
#[test]
fn test_unknown_extension() {
assert_eq!(Language::from_extension("xyz"), Language::Unknown);
assert_eq!(Language::from_extension("abc123"), Language::Unknown);
}
#[test]
fn test_no_extension_path() {
assert_eq!(
Language::from_path(&PathBuf::from("noextension")),
Language::Unknown
);
}
#[test]
fn test_case_insensitive_extension() {
assert_eq!(Language::from_extension("RS"), Language::Rust);
assert_eq!(Language::from_extension("PY"), Language::Python);
assert_eq!(Language::from_extension("Js"), Language::JavaScript);
}
#[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!(lang, deserialized);
}
#[test]
fn test_language_stats_fields() {
let stats = LanguageStats {
language: Language::Rust,
file_count: 10,
total_lines: 1000,
code_lines: 800,
comment_lines: 150,
blank_lines: 50,
};
assert_eq!(stats.language, Language::Rust);
assert_eq!(stats.file_count, 10);
assert_eq!(stats.total_lines, 1000);
}
#[test]
fn test_all_languages_have_names() {
let languages = [
Language::Rust,
Language::C,
Language::Cpp,
Language::Go,
Language::Zig,
Language::Java,
Language::Kotlin,
Language::Scala,
Language::Groovy,
Language::Clojure,
Language::CSharp,
Language::FSharp,
Language::VisualBasic,
Language::Python,
Language::JavaScript,
Language::TypeScript,
Language::Ruby,
Language::PHP,
Language::Perl,
Language::Lua,
Language::Haskell,
Language::Elixir,
Language::Erlang,
Language::OCaml,
Language::ReasonML,
Language::Elm,
Language::PureScript,
Language::Lean,
Language::Swift,
Language::ObjectiveC,
Language::Dart,
Language::Bash,
Language::Zsh,
Language::Fish,
Language::PowerShell,
Language::SQL,
Language::HCL,
Language::YAML,
Language::TOML,
Language::JSON,
Language::XML,
Language::Markdown,
Language::LaTeX,
Language::AsciiDoc,
Language::Makefile,
Language::CMake,
Language::Bazel,
Language::Gradle,
Language::Maven,
Language::Solidity,
Language::VHDL,
Language::Verilog,
Language::R,
Language::Julia,
Language::Matlab,
Language::Assembly,
Language::Unknown,
];
for lang in languages {
let name = lang.name();
assert!(!name.is_empty(), "Language {:?} should have a name", lang);
}
}
#[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));
assert!(!set.contains(&Language::Go));
}
}
#[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);
}
}
}