vebRoot

1 auto currentSeed = unpredictableSeed();
2 static if(vdebug){write("UT: 1. use case       "); writeln("seed: ", currentSeed);} 
3 rndGenInUse.seed(currentSeed); //initialize the random generator
4 
5 size_t M = uniform(2U, baseSize, rndGenInUse); //set universe size to some integer (small). 
6 size_t N = uniform(1U, M, rndGenInUse); //set universe size to some integer (small). 
7 
8 auto vT = vebRoot(M); 
9 assert(vT.empty); 
10 
11 size_t[] testArray = new size_t[N]; 
12 M.iota.randomCover(rndGenInUse).take(N)
13         .enumerate
14         .tee!(el => testArray[el.index] = el.value)
15         .each!(el => vT.insert(el.value));
16 
17 assert(vT.front == testArray.sort.front); 
18 assert(vT.back == testArray.sort.back); 
19 assert(vT().front == testArray.sort.front);  
20 assert(vT().back == testArray.sort.back); 
21 assert(vT[].front == 0); 
22 assert(vT[].back == vT.universe);
23 assert(vT.length == testArray.length); 
24 assert(vT() == testArray); 
25 assert(vT.capacity == baseSize); 
26 assert(vT.universe == M); 
27 assert(!vT.empty); 
28 testArray.each!(el => assert(el in vT)); 
29 size_t counter; 
30 for(auto el = vT.front; el != vT.back; el = vT.successor(el.get))
31 {
32     assert(el.get == testArray.sort[counter]); 
33     ++counter; 
34 }
35 for(auto el = vT.back; el != vT.front; el = vT.predecessor(el.get))
36 {
37     assert(el.get == testArray.sort[counter]); 
38     --counter; 
39 }
40 auto secondElementQ = vT.successor(testArray.sort[0]); 
41 if(!secondElementQ.isNull)
42 {
43     assert(testArray.sort.lowerBound(secondElementQ.get).length == 1); 
44 }
45 
46 auto randomElement = testArray[uniform(0, testArray.length, rndGenInUse)]; 
47 assert(!vT.insert(randomElement)); 
48 
49 auto vTdeepCopy = vT.dup; 
50 foreach(el; testArray)
51 {
52     vT.remove(el); 
53 }
54 assert(vT.empty); 
55 assert(!vT.length);
56 assert(vTdeepCopy.length == testArray.length); 
57 
58 auto vTdeepCopy2 = vTdeepCopy.dup; 
59 
60 vTdeepCopy2.remove(testArray[0]); 
61 assert(vTdeepCopy2.length + 1 == testArray.length); 
62 auto inclusiveSlice = vTdeepCopy[]; 
63 if(0 in vTdeepCopy)
64 {
65     assert(inclusiveSlice.length == testArray.length + 1); 
66 }
67 else
68 {
69     assert(inclusiveSlice.length == testArray.length + 2); 
70 }
71 
72 auto exclusiveSlice = vTdeepCopy(); 
73 assert(exclusiveSlice.length == vTdeepCopy.length); 
74 foreach(el; vTdeepCopy)
75 {
76     assert(el in exclusiveSlice);
77 }
78 foreach(el; exclusiveSlice)
79 {
80     assert(el in vTdeepCopy); 
81 }
82 auto shallowCopyFromRoot = vTdeepCopy; 
83 static assert(is(typeof(vTdeepCopy) : VEBroot!T, T...)); 
84 assert(!vTdeepCopy.empty); 
85 assert(vTdeepCopy.length == vTdeepCopy().length); 
86 assert(shallowCopyFromRoot == vTdeepCopy().save); 
87 
88 inclusiveSlice = vTdeepCopy[]; 
89 auto shallowCopyFromSlice = inclusiveSlice.save;
90 assert(inclusiveSlice.front == shallowCopyFromSlice.front);
91 inclusiveSlice.popFront; 
92 assert(inclusiveSlice.front != shallowCopyFromSlice.front);
93 
94 if(0 in vTdeepCopy)
95 {
96     assert(inclusiveSlice.front == vTdeepCopy.successor(0));
97 }
98 else
99 {
100     assert(inclusiveSlice.front == vTdeepCopy.front); 
101 }
102 
103 assert(vTdeepCopy() == testArray);
104 auto vTdeepCopy3 = vT.dup; 
105 auto vTshallowCopy = vT; 
106 assert(shallowCopyFromRoot.front == vTdeepCopy.front); 
107 vTdeepCopy.remove(vTdeepCopy.front.get); 
108 assert(shallowCopyFromRoot.front == vTdeepCopy.front); 
109 
110 assert(vTshallowCopy == vT);
111 assert(vTdeepCopy3 == vT); 
112 
113 assert(vT() == vT); 
114 assert(vT == vT());

1 auto currentSeed = unpredictableSeed();
2 static if(vdebug){write("UT: 2. use case       "); writeln("seed: ", currentSeed);} 
3 rndGenInUse.seed(currentSeed); //initialize the random generator
4 
5 size_t M = uniform(baseSize + 1, testedSize, rndGenInUse); //set universe size to some integer (small). 
6 size_t N = uniform(1U, min(M, allowedArraySize), rndGenInUse); //set universe size to some integer (small). 
7 
8 auto vT = vebRoot(M); 
9 assert(vT.empty); 
10 
11 size_t[] testArray = new size_t[N]; 
12 
13 M.iota.randomCover(rndGenInUse).take(N)
14         .enumerate
15         .tee!(el => testArray[el.index] = el.value)
16         .each!(el => vT.insert(el.value));
17 
18 assert(vT.front == testArray.sort.front); 
19 assert(vT.back == testArray.sort.back); 
20 assert(vT().front == testArray.sort.front);  
21 assert(vT().back == testArray.sort.back); 
22 assert(vT[].front == 0); 
23 assert(vT[].back == vT.universe);
24 assert(vT.length == testArray.length); 
25 assert(vT() == testArray); 
26 assert(vT.capacity == M.nextPow2); 
27 assert(vT.universe == M); 
28 assert(!vT.empty); 
29 
30 testArray.each!(el => assert(el in vT)); 
31 size_t counter; 
32 for(auto el = vT.front; el != vT.back; el = vT.successor(el.get))
33 {
34     assert(el.get == testArray.sort[counter]); 
35     ++counter; 
36 }
37 for(auto el = vT.back; el != vT.front; el = vT.predecessor(el.get))
38 {
39     assert(el.get == testArray.sort[counter]); 
40     --counter; 
41 }
42 
43 auto secondElementQ = vT.successor(testArray.sort[0]); 
44 if(!secondElementQ.isNull)
45 {
46     assert(testArray.sort.lowerBound(secondElementQ.get).length == 1); 
47 }
48 
49 auto randomElement = testArray[uniform(0, testArray.length, rndGenInUse)]; 
50 assert(!vT.insert(randomElement)); 
51 
52 auto vTdeepCopy = vT.dup; 
53 foreach(el; testArray)
54 {
55     vT.remove(el); 
56 }
57 assert(vT.empty); 
58 assert(!vT.length);
59 assert(vTdeepCopy.length == testArray.length); 
60 
61 auto vTdeepCopy2 = vTdeepCopy.dup; 
62 
63 vTdeepCopy2.remove(testArray[0]); 
64 assert(vTdeepCopy2.length + 1 == testArray.length); 
65 
66 auto inclusiveSlice = vTdeepCopy[]; 
67 if(0 in vTdeepCopy)
68 {
69     assert(inclusiveSlice.length == testArray.length + 1); 
70 }
71 else
72 {
73     assert(inclusiveSlice.length == testArray.length + 2); 
74 }
75 
76 auto exclusiveSlice = vTdeepCopy(); 
77 assert(exclusiveSlice.length == vTdeepCopy.length); 
78 foreach(el; vTdeepCopy)
79 {
80     assert(el in exclusiveSlice);
81 }
82 foreach(el; exclusiveSlice)
83 {
84     assert(el in vTdeepCopy); 
85 }
86 
87 auto shallowCopyFromRoot = vTdeepCopy; 
88 assert(shallowCopyFromRoot == vTdeepCopy().save); 
89 inclusiveSlice = vTdeepCopy[]; 
90 auto shallowCopyFromSlice = inclusiveSlice.save;
91 assert(inclusiveSlice.front == shallowCopyFromSlice.front);
92 inclusiveSlice.popFront; 
93 assert(inclusiveSlice.front != shallowCopyFromSlice.front);
94 
95 if(0 in vTdeepCopy)
96 {
97     assert(inclusiveSlice.front == vTdeepCopy.successor(0));
98 }
99 else
100 {
101     assert(inclusiveSlice.front == vTdeepCopy.front); 
102 }
103 
104 assert(vTdeepCopy() == testArray);
105 auto vTdeepCopy3 = vT.dup; 
106 auto vTshallowCopy = vT; 
107 assert(shallowCopyFromRoot.front == vTdeepCopy.front); 
108 vTdeepCopy.remove(vTdeepCopy.front.get); 
109 assert(shallowCopyFromRoot.front == vTdeepCopy.front); 
110 
111 assert(vTshallowCopy == vT);
112 assert(vTdeepCopy3 == vT); 
113 
114 assert(vT() == vT); 
115 assert(vT == vT());