unit_threaded.static

1 /**
2    A module for static constructors to avoid cyclic dependencies.
3  */
4 module unit_threaded.static_;
5 
6 version(unitThreadedLight) {
7 
8     shared static this() {
9         import std.algorithm: canFind, startsWith;
10         import std.parallelism: parallel;
11         import core.runtime: Runtime;
12 
13         Runtime.moduleUnitTester = () {
14 
15             // ModuleInfo has opApply, can't use parallel on that so we collect
16             // all the modules with unit tests first
17             ModuleInfo*[] modules;
18             foreach(module_; ModuleInfo) {
19                 if(module_ && module_.unitTest)
20                     modules ~= module_;
21             }
22 
23             version(unitUnthreaded)
24                 enum singleThreaded = true;
25             else
26                 const singleThreaded = Runtime.args.canFind("-s") || Runtime.args.canFind("--single");
27 
28             void runModuleTests(ModuleInfo* module_) {
29                 version(testing_unit_threaded) {
30                     const shouldTest =
31                     module_.name.startsWith("unit_threaded.ut") &&
32                     !module_.name.startsWith("unit_threaded.ut.modules");
33                 } else
34                       enum shouldTest = true;
35 
36                 if(shouldTest)
37                     module_.unitTest()();
38             }
39 
40             if(singleThreaded)
41                 foreach(module_; modules)
42                     runModuleTests(module_);
43              else
44                 foreach(module_; modules.parallel)
45                     runModuleTests(module_);
46 
47             return true;
48         };
49     }
50 }
51 
52 static this() {
53     import unit_threaded.io: _useEscCodes, shouldUseEscCodes;
54     version (Posix) {
55         import std.stdio: stdout;
56         import core.sys.posix.unistd: isatty;
57         _useEscCodes = shouldUseEscCodes;
58     }
59 }