hsperf 0.2.0

A library to monitor java virtual machines performance data
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::{
    EntryValue,
    perf_data::{Unit, Variability},
};

/// Entry read from the Hotspot Data that is characterized as changing in either a Monotonic or Variable way
pub struct VariableEntry {
    name: String,
    value: EntryValue,
    variability: Variability,
    unit: Unit,
}

impl VariableEntry {
    pub(crate) fn new(
        name: String,
        value: EntryValue,
        variability: Variability,
        unit: Unit,
    ) -> Self {
        Self {
            name,
            value,
            variability,
            unit,
        }
    }

    /// The name of the entry as published by the JVM.
    pub fn name(&self) -> &String {
        &self.name
    }

    /// The last value read for the entry.
    pub fn value(&self) -> &EntryValue {
        &self.value
    }

    /// Updates the value when the new_value is different
    /// returns None when the new_value is the same as the existing value,
    /// Some of a reference to itself when the value was updated.
    pub fn refresh_value(&mut self, new_value: EntryValue) -> &Self {
        self.value = new_value;
        self
    }

    /// The variability of the entry as published by the JVM
    pub fn variability(&self) -> Variability {
        self.variability
    }

    /// The unit of the entry as published by the JVM
    pub fn unit(&self) -> Unit {
        self.unit
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        EntryValue,
        perf_data::{Unit, Variability},
        variable_entry::VariableEntry,
    };

    #[test]
    fn name_returns_the_name() {
        let name = "test1".to_string();
        let value = EntryValue::Int(1234);
        let variability = Variability::Monotonic;
        let unit = Unit::Hertz;
        let tested_entry = VariableEntry::new(name.clone(), value, variability, unit);

        assert_eq!(name, *tested_entry.name());
    }

    #[test]
    fn value_returns_the_value() {
        let name = "test1".to_string();
        let value = EntryValue::Int(1234);
        let variability = Variability::Monotonic;
        let unit = Unit::Hertz;
        let tested_entry = VariableEntry::new(name, value, variability, unit);

        match tested_entry.value {
            EntryValue::Int(1234) => assert!(true),
            _ => assert!(false),
        }
    }

    #[test]
    fn variability_returns_the_variability() {
        let name = "test1".to_string();
        let value = EntryValue::Int(1234);
        let variability = Variability::Monotonic;
        let unit = Unit::Hertz;
        let tested_entry = VariableEntry::new(name, value, variability, unit);

        assert_eq!(variability, tested_entry.variability());
    }

    #[test]
    fn unit_returns_the_unit() {
        let name = "test1".to_string();
        let value = EntryValue::Int(1234);
        let variability = Variability::Monotonic;
        let unit = Unit::Hertz;
        let tested_entry = VariableEntry::new(name, value, variability, unit);

        assert_eq!(unit, tested_entry.unit());
    }

    #[test]
    fn refresh_value_is_self_when_changed() {
        let name = "test1".to_string();
        let value = EntryValue::Int(1234);
        let new_value = EntryValue::Int(1235);
        let variability = Variability::Monotonic;
        let unit = Unit::Hertz;
        let mut tested_entry = VariableEntry::new(name, value, variability, unit);

        let result = tested_entry.refresh_value(new_value);
        match result.value {
            EntryValue::Int(1235) => assert!(true),
            _ => assert!(false),
        }
    }
}