irc-rust 0.1.1

IRC Helper easing the access and creation of IRC Messages
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

extern crate rand;
extern crate test;

use test::Bencher;

use rand::Rng;

use crate::message::Message;

#[bench]
fn bench_parse(b: &mut Bencher) {
    b.iter(|| {
        let message = Message::new("@key1=value1;key2=value2 :name!user@host CMD param1 param2 :trailing");

        assert_eq!(message.to_string(), "@key1=value1;key2=value2 :name!user@host CMD param1 param2 :trailing");
        // 42 ns/iter

        let tags = message.tags().unwrap();
        let val = &tags["key1"];
        assert_eq!(val, "value1");
        let val = &tags["key2"];
        assert_eq!(val, "value2");
        // 189 ns/iter

        let mut tags = message.tags().unwrap().iter();
        let (key, val) = tags.next().unwrap();
        assert_eq!(key, "key1");
        assert_eq!(val, "value1");
        let (key, val) = tags.next().unwrap();
        assert_eq!(key, "key2");
        assert_eq!(val, "value2");
        // 319 ns/iter

        let prefix = message.prefix().unwrap();
        assert_eq!(prefix.name(), "name");
        assert_eq!(prefix.user().unwrap(), "user");
        assert_eq!(prefix.host().unwrap(), "host");
        // 519 ns/iter

        assert_eq!(message.command(), "CMD");
        // 585 ns/iter

        let params = message.params().unwrap();
        let mut iter = params.iter();
        assert_eq!(iter.next().unwrap(), "param1");
        assert_eq!(iter.next().unwrap(), "param2");
        assert!(iter.next().is_none());
        assert_eq!(params.trailing.unwrap(), "trailing")
        // 793 ns/iter
    });
}

#[bench]
fn bench_tag_index(b: &mut Bencher) {
    let mut str = String::from("@");
    for i in 0..1000 {
        str = format!("{}key{}=value{}", str, i, i);
        if i != 1000 {
            str.push(';');
        }
    }
    str.push_str(" CMD");
    let message = Message::new(str.as_str());
    let tags = message.tags().unwrap();

    b.iter(|| {
        let mut rng = rand::thread_rng();
        let ikey = rng.gen_range(0, 1000);
        let skey = format!("key{}", ikey);
        let val = &tags[&skey];
        assert_eq!(val, format!("value{}", ikey));
    })
}

#[bench]
fn bench_params(b: &mut Bencher) {
    let mut str = String::from("CMD");
    for _ in 0..100 {
        str.push_str(" param");
    }
    let message = Message::new(str.as_str());

    b.iter(|| {
        for param in message.params().unwrap().iter() {
            assert_eq!(param, "param")
        }
    });
}