test: add unit tests for Language trait implementations

Add comprehensive tests for all 17 supported language implementations:
- C, C++, C#, Dart, Go, Haskell, Java, JavaScript, Kotlin, PHP
- Python, Ruby, Rust, Scala, Swift, TypeScript, Zig
- Test name, extensions, display_name, color, comment validation
- Improve language model test coverage

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

tests/unit/domain/models/languages/c_tests.rs

@@ -0,0 +1,68 @@
+use gittype::domain::models::languages::c::C;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = C;
+    assert_eq!(lang.name(), "c");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = C;
+    assert_eq!(lang.extensions(), vec!["c", "h"]);
+}
+
+#[test]
+fn test_display_name() {
+    let lang = C;
+    assert_eq!(lang.display_name(), "C");
+}
+
+#[test]
+fn test_color() {
+    let lang = C;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = C;
+    let code = "// comment\nint main() { return 0; }";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_c::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = C;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = C;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("C"));
+}
+
+#[test]
+fn test_hash() {
+    use std::collections::HashSet;
+    let lang = C;
+    let mut set = HashSet::new();
+    set.insert(lang);
+    assert!(set.contains(&C));
+}

tests/unit/domain/models/languages/cpp_tests.rs

@@ -0,0 +1,61 @@
+use gittype::domain::models::languages::cpp::Cpp;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = Cpp;
+    assert_eq!(lang.name(), "cpp");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = Cpp;
+    let exts = lang.extensions();
+    assert!(exts.contains(&"cpp"));
+    assert!(exts.contains(&"cc"));
+}
+
+#[test]
+fn test_display_name() {
+    let lang = Cpp;
+    assert_eq!(lang.display_name(), "C++");
+}
+
+#[test]
+fn test_color() {
+    let lang = Cpp;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = Cpp;
+    let code = "// comment\nint main() { return 0; }";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_cpp::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = Cpp;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = Cpp;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("Cpp"));
+}

tests/unit/domain/models/languages/csharp_tests.rs

@@ -0,0 +1,61 @@
+use gittype::domain::models::languages::csharp::CSharp;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = CSharp;
+    assert_eq!(lang.name(), "csharp");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = CSharp;
+    let exts = lang.extensions();
+    assert!(exts.contains(&"cs"));
+    assert!(exts.contains(&"csx"));
+}
+
+#[test]
+fn test_display_name() {
+    let lang = CSharp;
+    assert_eq!(lang.display_name(), "C#");
+}
+
+#[test]
+fn test_color() {
+    let lang = CSharp;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = CSharp;
+    let code = "// comment\nclass Test { }";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_c_sharp::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = CSharp;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = CSharp;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("CSharp"));
+}

tests/unit/domain/models/languages/dart_tests.rs

@@ -0,0 +1,57 @@
+use gittype::domain::models::languages::dart::Dart;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = Dart;
+    assert_eq!(lang.name(), "dart");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = Dart;
+    assert_eq!(lang.extensions(), vec!["dart"]);
+}
+
+#[test]
+fn test_display_name() {
+    let lang = Dart;
+    assert_eq!(lang.display_name(), "Dart");
+}
+
+#[test]
+fn test_color() {
+    let lang = Dart;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = Dart;
+    let code = "// comment\n/// doc comment\nvoid main() { }";
+    let mut parser = tree_sitter::Parser::new();
+    parser.set_language(&tree_sitter_dart::language()).unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" || child.kind() == "documentation_comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = Dart;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = Dart;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("Dart"));
+}

tests/unit/domain/models/languages/go_tests.rs

@@ -0,0 +1,59 @@
+use gittype::domain::models::languages::go::Go;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = Go;
+    assert_eq!(lang.name(), "go");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = Go;
+    assert_eq!(lang.extensions(), vec!["go"]);
+}
+
+#[test]
+fn test_display_name() {
+    let lang = Go;
+    assert_eq!(lang.display_name(), "Go");
+}
+
+#[test]
+fn test_color() {
+    let lang = Go;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = Go;
+    let code = "// comment\nfunc main() { }";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_go::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = Go;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = Go;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("Go"));
+}

tests/unit/domain/models/languages/haskell_tests.rs

@@ -0,0 +1,61 @@
+use gittype::domain::models::languages::haskell::Haskell;
+use gittype::domain::models::Language;
+
+#[test]
+fn test_name() {
+    let lang = Haskell;
+    assert_eq!(lang.name(), "haskell");
+}
+
+#[test]
+fn test_extensions() {
+    let lang = Haskell;
+    let exts = lang.extensions();
+    assert!(exts.contains(&"hs"));
+    assert!(exts.contains(&"lhs"));
+}
+
+#[test]
+fn test_display_name() {
+    let lang = Haskell;
+    assert_eq!(lang.display_name(), "Haskell");
+}
+
+#[test]
+fn test_color() {
+    let lang = Haskell;
+    let _ = lang.color();
+}
+
+#[test]
+fn test_is_valid_comment_node() {
+    let lang = Haskell;
+    let code = "-- comment\nmain = return ()";
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_haskell::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(code, None).unwrap();
+    let root = tree.root_node();
+
+    let mut cursor = root.walk();
+    for child in root.children(&mut cursor) {
+        if child.kind() == "comment" {
+            assert!(lang.is_valid_comment_node(child));
+        }
+    }
+}
+
+#[test]
+fn test_clone() {
+    let lang = Haskell;
+    let cloned = lang;
+    assert_eq!(lang, cloned);
+}
+
+#[test]
+fn test_debug() {
+    let lang = Haskell;
+    let debug_str = format!("{:?}", lang);
+    assert!(debug_str.contains("Haskell"));
+}