jbuild 0.1.8

High-performance Java build tool supporting Maven and Gradle
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Tests for TreeWalker functionality

use jbuild::checkstyle::api::file::FileText;
use jbuild::checkstyle::checks::empty_catch_block::EmptyCatchBlockCheck;
use jbuild::checkstyle::runner::tree_walker::TreeWalker;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::Mutex;

#[test]
fn test_tree_walker_new() {
    let _walker = TreeWalker::new();
    assert!(true, "TreeWalker should be created");
}

#[test]
fn test_tree_walker_add_check() {
    let mut walker = TreeWalker::new();
    let check = Arc::new(Mutex::new(EmptyCatchBlockCheck::new()));
    let result = walker.add_check(check);
    assert!(result.is_ok(), "Should add check successfully");
}

#[test]
fn test_tree_walker_process_file() {
    let walker = TreeWalker::new();
    let java_code = "public class Test {}";
    let file_text = FileText::new(PathBuf::from("Test.java"), java_code.to_string());
    
    let result = walker.process_file(&PathBuf::from("Test.java"), &file_text);
    assert!(result.is_ok(), "Should process file successfully");
}

#[test]
fn test_tree_walker_process_file_with_check() {
    let mut walker = TreeWalker::new();
    let check = Arc::new(Mutex::new(EmptyCatchBlockCheck::new()));
    walker.add_check(check).unwrap();
    
    let java_code = r#"
public class Test {
    public void test() {
        try {
            doSomething();
        } catch (Exception e) {
        }
    }
}
"#;
    let file_text = FileText::new(PathBuf::from("Test.java"), java_code.to_string());
    
    let result = walker.process_file(&PathBuf::from("Test.java"), &file_text);
    assert!(result.is_ok(), "Should process file with check");
    
    let violations = result.unwrap();
    // May or may not find violations depending on parser mapping
    println!("Found {} violations", violations.len());
}

#[test]
fn test_tree_walker_multiple_checks() {
    let mut walker = TreeWalker::new();
    let check1 = Arc::new(Mutex::new(EmptyCatchBlockCheck::new()));
    let check2 = Arc::new(Mutex::new(EmptyCatchBlockCheck::new()));
    
    walker.add_check(check1).unwrap();
    walker.add_check(check2).unwrap();
    
    let java_code = "public class Test {}";
    let file_text = FileText::new(PathBuf::from("Test.java"), java_code.to_string());
    
    let result = walker.process_file(&PathBuf::from("Test.java"), &file_text);
    assert!(result.is_ok(), "Should process file with multiple checks");
}

#[test]
fn test_tree_walker_empty_file() {
    let walker = TreeWalker::new();
    let file_text = FileText::new(PathBuf::from("Test.java"), String::new());
    
    let result = walker.process_file(&PathBuf::from("Test.java"), &file_text);
    // Should handle empty file gracefully
    assert!(result.is_ok(), "Should handle empty file");
}