test_helpers source code

1 module test_helpers;
2 
3 import std.stdint;
4 import std.datetime;
5 
6 /** Shorthand for 2^^20 bytes */
7 enum mega = 1024 * 1024;
8 
9 /** Get duration as a float in seconds
10  * Param: duration
11  * Returns: duration as float, unit seconds
12  */
13 float getFloatSecond(Duration duration)
14 {
15     const auto ns_duration = duration.total!"nsecs";
16     const float second_duration = float(ns_duration) / 10 ^^ 9;
17     return second_duration;
18 }
19 
20 unittest
21 {
22     import std.math.operations;
23 
24     auto s = getFloatSecond(dur!"seconds"(1));
25     assert(isClose(s, 1.0));
26     s = getFloatSecond(dur!"msecs"(500));
27     assert(isClose(s, 0.5));
28     s = getFloatSecond(dur!"usecs"(500));
29     assert(isClose(s, 0.0005));
30 }
31 
32 /** Calculate MB/s from bytesize and a Duration value
33  * Param: byteSize - size_t Size of Data processed
34  * Param: duration - Duration of processing
35  * Returns:
36  *   float Megabyte per second
37  */
38 float getMegaBytePerSeconds(size_t byteSize, Duration duration)
39 {
40     enum mega = 2 ^^ 20;
41     const float second_duration = getFloatSecond(duration);
42     const float megaBytesPerSec = (byteSize != 0) ?
43         (float(byteSize) / mega) / float(second_duration) :
44         float.nan;
45     return megaBytesPerSec;
46 }
47 
48 unittest
49 {
50     import std.math.operations;
51 
52     auto mbs = getMegaBytePerSeconds(150 * 2 ^^ 20, dur!"seconds"(1));
53     assert(isClose(mbs, 150.0));
54     mbs = getMegaBytePerSeconds(10 * 2 ^^ 20, dur!"msecs"(500));
55     assert(isClose(mbs, 20.0));
56     mbs = getMegaBytePerSeconds(10 * 2 ^^ 20, dur!"usecs"(500));
57     assert(isClose(mbs, 20_000.0));
58 }
59 
60 /** Return compression ratio from unpacked/packed sizes
61  * Param: unpacked_size - size_t Unpacked length
62  * Param: packed_size - size_t Packed length
63  * Returns:
64  *   float with ratio. Values > 1.0 denote increased size after compression
65  */
66 float getCompressionRatio(size_t unpacked_size, size_t packed_size)
67 {
68     return packed_size > 0 ? float(packed_size) / float(unpacked_size) : float.nan;
69 }
70 
71 unittest
72 {
73     import std.math.operations;
74     float ratio;
75     ratio = getCompressionRatio( 1000, 1000);
76     assert( isClose( ratio, 1.0f ));
77     ratio = getCompressionRatio( 1000, 500);
78     assert( isClose( ratio, 0.5f ));
79     ratio = getCompressionRatio( 1000, 2000);
80     assert( isClose( ratio, 2.0f ));
81     ratio = getCompressionRatio( 0, 0);
82     import std.math;
83     assert( isNaN( ratio ));
84 }