qutonium 0.1.6

simplify unit testing with a functional testing framework 📈
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

use std::time::{Duration, Instant};


use miniserde::Serialize;


#[derive(Copy, Clone, Debug, Serialize)]
pub enum TimeUnitType {
  Microseconds,
  Milliseconds,
  Nanoseconds,
  Seconds,
}


#[derive(Clone, Copy, Debug, Serialize)]
pub struct TimeUnit {
  pub micros: u64,
  pub millis: u64,
  pub nanos: u64,
  pub secs: u64,
}


#[derive(Clone, Copy)]
pub struct Time {
  pub start: Option<Instant>,
  pub end: Option<Duration>,
  pub unit: TimeUnit,
}


impl Time {
  pub fn new () -> Self {
    Time {
      end: None,
      start: None,
      unit: TimeUnit {
        micros: 0,
        millis: 0,
        nanos: 0,
        secs: 0,
      },
    }
  }

  pub fn start (mut self) -> Option<Instant> {
    self.start = Some(Instant::now());
    self.start
  }

  pub fn end (mut self) -> Option<Duration> {
    self.end = match self.start {
      Some(start) => Some(start.elapsed()),
      _ => None,
    };

    self.end
  }
}