jvmti 0.5.0

JVM TI Rust binding
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
86
87

extern crate jvmti;

#[cfg(test)]
mod tests {

    use jvmti::agent::Agent;
    use jvmti::emulator::JVMEmulator;
    use jvmti::runtime::MethodInvocationEvent;
    use jvmti::thread::Thread;
    use jvmti::version::VersionNumber;

    #[test]
    fn agents_are_fucking_even_working() {
        let emulator = JVMEmulator::new();
        let agent = Agent::new_from(Box::new(emulator));
        let version = agent.get_version();

        assert_eq!(0x7FFF, version.major_version);
    }

    #[test]
    fn agents_are_initialized_with_empty_capabilities() {
        let emulator = JVMEmulator::new();
        let agent = Agent::new_from(Box::new(emulator));

        assert_eq!(false, agent.capabilities.can_suspend);
        assert_eq!(false, agent.capabilities.can_pop_frame);
        assert_eq!(false, agent.capabilities.can_generate_monitor_events);
        assert_eq!(false, agent.capabilities.can_generate_method_entry_events);
        assert_eq!(false, agent.capabilities.can_generate_method_exit_events);
        assert_eq!(false, agent.capabilities.can_generate_vm_object_alloc_events);
        assert_eq!(false, agent.capabilities.can_generate_breakpoint_events);
        // TODO this test is not complete at all. surprisingly
    }

    #[test]
    fn agents_respond_to_shutdown() {
        let emulator = JVMEmulator::new();
        let agent = Agent::new_from(Box::new(emulator));
        agent.shutdown();
    }

    #[test]
    fn agents_provide_with_version_numbers() {
        let emulator = JVMEmulator::new();
        let agent = Agent::new_from(Box::new(emulator));
        let version = agent.get_version();
        let unknown_version = VersionNumber::unknown();
        assert_eq!(unknown_version.major_version, version.major_version);
        assert_eq!(unknown_version.minor_version, version.minor_version);
        assert_eq!(unknown_version.micro_version, version.micro_version);
    }

    #[test]
    fn callbacks_trigger_capabilities() {
        let emulator = JVMEmulator::new();
        let mut agent = Agent::new_from(Box::new(emulator));

        agent.on_method_entry(Some(test_on_method_entry));
        assert_eq!(true, agent.capabilities.can_generate_method_entry_events);
        agent.on_method_entry(None);
        assert_eq!(false, agent.capabilities.can_generate_method_entry_events);

        assert_eq!(false, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_wait(Some(test_on_monitor_events));
        assert_eq!(true, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_waited(Some(test_on_monitor_events));
        assert_eq!(true, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_contended_enter(Some(test_on_monitor_events));
        assert_eq!(true, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_wait(None);
        assert_eq!(true, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_waited(None);
        assert_eq!(true, agent.capabilities.can_generate_monitor_events);
        agent.on_monitor_contended_enter(None);
    }

    #[allow(unused_variables)]
    fn test_on_method_entry(event: MethodInvocationEvent) {
        // this is a callback method for testing purposes
    }

    #[allow(unused_variables)]
    fn test_on_monitor_events(thread: Thread) {
        // this is a callback method for testing purposes
    }
}