fn test_get_named_events()

in src/data/perf_stat.rs [636:687]

• 46 lines of code
• 5 McCabe index (conditional complexity)

    fn test_get_named_events() {
        let mut perf_stat = PerfStatRaw::new();
        let mut buffer: Vec<Data> = Vec::<Data>::new();
        let mut processed_buffer: Vec<ProcessedData> = Vec::new();
        let params = CollectorParams::new();

        match perf_stat.prepare_data_collector(&params) {
            Err(e) => {
                if let Some(os_error) = e.downcast_ref::<std::io::Error>() {
                    match os_error.kind() {
                        ErrorKind::PermissionDenied => {
                            panic!("Set /proc/sys/kernel/perf_event_paranoid to 0")
                        }
                        ErrorKind::NotFound => println!("Instance does not expose Perf counters"),
                        _ => panic!("{}", os_error),
                    }
                }
            }
            Ok(_) => {
                perf_stat.collect_data(&params).unwrap();
                buffer.push(Data::PerfStatRaw(perf_stat));
                for buf in buffer {
                    processed_buffer.push(PerfStat::new().process_raw_data(buf).unwrap());
                }
                let events = PerfStat::new()
                    .get_data(
                        processed_buffer,
                        "run=test&get=keys".to_string(),
                        &mut DataMetrics::new(String::new()),
                    )
                    .unwrap();
                let values: Vec<String> = serde_json::from_str(&events).unwrap();

                // Make sure at least ipc was reported (should be present everywhere)
                assert!(values.contains(&"ipc".to_owned()));

                // Make sure all keys that were reported were returned the same number of
                // times (in other words that they were all reported for all CPUs)
                let mut event_counts = HashMap::new();
                for event in values {
                    if let Some(c) = event_counts.get_mut(&event) {
                        *c += 1;
                    } else {
                        event_counts.insert(event, 1);
                    }
                }
                let mut counts: Vec<_> = event_counts.into_values().collect();
                counts.dedup();
                assert_eq!(counts.len(), 1);
            }
        }
    }