unit_threaded.ut.randomized.gen source code

1 module unit_threaded.ut.randomized.gen;
2 
3 import unit_threaded.randomized.gen;
4 
5 @safe pure unittest {
6     import unit_threaded.asserts: assertEqual;
7     import std.random: Random;
8 
9     auto rnd = Random(1337);
10     Gen!int gen;
11     assertEqual(gen.gen(rnd), 0);
12     assertEqual(gen.gen(rnd), 1);
13     assertEqual(gen.gen(rnd), int.min);
14     assertEqual(gen.gen(rnd), int.max);
15     assertEqual(gen.gen(rnd), 1125387415); //1st non front-loaded value
16 }
17 
18 @safe unittest {
19     // not pure because of floating point flags
20     import unit_threaded.asserts: assertEqual;
21     import std.math: approxEqual;
22     import std.conv: to;
23     import std.random: Random;
24 
25     auto rnd = Random(1337);
26     Gen!float gen;
27     assertEqual(gen.gen(rnd), 0);
28     assertEqual(gen.gen(rnd), float.epsilon);
29     assertEqual(gen.gen(rnd), float.min_normal);
30     assert(approxEqual(gen.gen(rnd), 6.022E23), gen.value.to!string);
31     assert(approxEqual(gen.gen(rnd), 1.57791E23), gen.value.to!string);
32 }
33 
34 
35 @safe unittest {
36     // not pure because of floating point flags
37     import unit_threaded.asserts: assertEqual;
38     import std.math: approxEqual;
39     import std.conv: to;
40     import std.random: Random;
41 
42     auto rnd = Random(1337);
43     Gen!(float, 0, 5) gen;
44     assertEqual(gen.gen(rnd), 0);
45     assertEqual(gen.gen(rnd), float.epsilon);
46     assertEqual(gen.gen(rnd), float.min_normal);
47     assertEqual(gen.gen(rnd), 5);
48     assert(approxEqual(gen.gen(rnd), 1.31012), gen.value.to!string);
49 }
50 
51 unittest
52 {
53     import std.meta : AliasSeq, aliasSeqOf;
54     import std.range : iota;
55     import std.array : empty;
56     import std.random: Random;
57     import unit_threaded.asserts;
58 
59     foreach (index, T; AliasSeq!(string, wstring, dstring)) {
60         auto r = Random(1337);
61         Gen!T a;
62         T expected = "";
63         assertEqual(a.gen(r), expected);
64         expected = "a";
65         assertEqual(a.gen(r), expected);
66         expected = "é";
67         assertEqual(a.gen(r), expected);
68         assert(a.gen(r).length > 1);
69     }
70 }
71 
72 @safe unittest {
73     import unit_threaded.asserts;
74     import std.random: Random;
75 
76     auto rnd = Random(1337);
77     GenASCIIString!() gen;
78     assertEqual(gen.gen(rnd), "");
79     assertEqual(gen.gen(rnd), "a");
80     version(Windows)
81         assertEqual(gen.gen(rnd), "yt4>%PnZwJ*Nv3L5:9I#N_ZK");
82     else
83         assertEqual(gen.gen(rnd), "i<pDqp7-LV;W`d)w/}VXi}TR=8CO|m");
84 }
85 
86 @("Gen!int[] generates random arrays of int")
87 @safe unittest {
88     import unit_threaded.asserts: assertEqual;
89     import std.random: Random;
90 
91     auto rnd = Random(1337);
92     auto gen = Gen!(int[], 1, 10)();
93 
94     // first the front-loaded values
95     assertEqual(gen.gen(rnd), []);
96     version(Windows)
97         assertEqual(gen.gen(rnd), [0, 1]);
98     else
99         assertEqual(gen.gen(rnd), [0, 1, -2147483648, 2147483647, 681542492, 913057000, 1194544295, -1962453543, 1972751015]);
100 }
101 
102 @("Gen!ubyte[] generates random arrays of ubyte")
103 @safe unittest {
104     import unit_threaded.asserts: assertEqual;
105     import std.random: Random;
106 
107     auto rnd = Random(1337);
108     auto gen = Gen!(ubyte[], 1, 10)();
109     assertEqual(gen.gen(rnd), []);
110 }
111 
112 
113 @("Gen!double[] generates random arrays of double")
114 @safe unittest {
115     import unit_threaded.asserts: assertEqual;
116     import std.random: Random;
117 
118     auto rnd = Random(1337);
119     auto gen = Gen!(double[], 1, 10)();
120 
121     // first the front-loaded values
122     assertEqual(gen.gen(rnd), []);
123     // then the pseudo-random ones
124     version(Windows)
125         assertEqual(gen.gen(rnd).length, 2);
126     else
127         assertEqual(gen.gen(rnd).length, 9);
128 }
129 
130 @("Gen!string[] generates random arrays of string")
131 @safe unittest {
132     import unit_threaded.asserts: assertEqual;
133     import std.random: Random;
134 
135     auto rnd = Random(1337);
136     auto gen = Gen!(string[])();
137 
138     assertEqual(gen.gen(rnd), []);
139     auto strings = gen.gen(rnd);
140     assert(strings.length > 1);
141     assertEqual(strings[1], "a");
142 }
143 
144 @("Gen!string[][] generates random arrays of string")
145 @safe unittest {
146     import unit_threaded.asserts: assertEqual;
147     import std.random: Random;
148 
149     auto rnd = Random(1337);
150     auto gen = Gen!(string[][])();
151 
152     assertEqual(gen.gen(rnd), []);
153     // takes too long
154     // auto strings = gen.gen(rnd);
155     // assert(strings.length > 1);
156 }
157 
158 @("Gen!bool generates random booleans")
159 @safe unittest {
160     import unit_threaded.asserts: assertEqual;
161     import std.random: Random;
162 
163     auto rnd = Random(1337);
164     auto gen = Gen!bool();
165 
166     assertEqual(gen.gen(rnd), true);
167     assertEqual(gen.gen(rnd), true);
168     assertEqual(gen.gen(rnd), false);
169     assertEqual(gen.gen(rnd), false);
170 }
171 
172 @("Gen char, wchar, dchar")
173 @safe unittest {
174     import unit_threaded.asserts: assertEqual;
175     import std.random: Random;
176 
177     {
178         auto rnd = Random(1337);
179         Gen!char gen;
180         assertEqual(cast(int)gen.gen(rnd), 151);
181     }
182     {
183         auto rnd = Random(1337);
184         Gen!wchar gen;
185         assertEqual(cast(int)gen.gen(rnd), 3223);
186     }
187     {
188         auto rnd = Random(1337);
189         Gen!dchar gen;
190         assertEqual(cast(int)gen.gen(rnd), 3223);
191     }
192 }
193 
194 @("struct")
195 @safe unittest {
196     import unit_threaded.asserts: assertEqual;
197     import std.random: Random;
198 
199     struct Foo {
200         int i;
201         string s;
202     }
203 
204     auto rnd = Random(1337);
205     Gen!Foo gen;
206     assertEqual(gen.gen(rnd), Foo(0, ""));
207     assertEqual(gen.gen(rnd), Foo(1, "a"));
208     assertEqual(gen.gen(rnd), Foo(int.min, "é"));
209 }
210 
211 @("class")
212 @safe unittest {
213     import unit_threaded.asserts: assertEqual;
214     import std.random: Random;
215 
216     static class Foo {
217         this() {}
218         this(int i, string s) { this.i = i; this.s = s; }
219         override string toString() @safe const pure nothrow {
220             import std.conv;
221             return text(`Foo(`, i, `, "`, s, `")`);
222         }
223         override bool opEquals(Object _rhs) @safe const pure nothrow {
224             auto rhs = cast(Foo)_rhs;
225             return i == rhs.i && s == rhs.s;
226         }
227         int i;
228         string s;
229     }
230 
231     auto rnd = Random(1337);
232     Gen!Foo gen;
233     assertEqual(gen.gen(rnd), new Foo(0, ""));
234     assertEqual(gen.gen(rnd), new Foo(1, "a"));
235     assertEqual(gen.gen(rnd), new Foo(int.min, "é"));
236 }