Mercurial > hg > orthanc-stone

comparison OrthancStone/UnitTestsSources/TestStrategy.cpp @ 1877:a2955abe4c2e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
skeleton for the RenderingPlugin
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 12 Jan 2022 08:23:38 +0100
parents UnitTestsSources/TestStrategy.cpp@7053b8a0aaec
children 07964689cb0b
comparison
equal deleted inserted replaced
1876:b1f510e601d2 1877:a2955abe4c2e
1 /**
2 * Stone of Orthanc
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2022 Osimis S.A., Belgium
6 * Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
7 *
8 * This program is free software: you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 **/
22
23
24 #include <gtest/gtest.h>
25
26 #include "../Sources/Loaders/BasicFetchingStrategy.h"
27 #include "../Sources/Loaders/BasicFetchingItemsSorter.h"
28
29 #include <OrthancException.h>
30
31
32 namespace
33 {
34 class StrategyTester : public boost::noncopyable
35 {
36 private:
37 std::map<unsigned int, unsigned int> qualities_;
38
39 public:
40 bool IsValidCommand(unsigned int item,
41 unsigned int quality)
42 {
43 if (qualities_.find(item) != qualities_.end() &&
44 qualities_[item] >= quality)
45 {
46 return false;
47 }
48 else
49 {
50 qualities_[item] = quality;
51 return true;
52 }
53 }
54
55 bool HasFinished(OrthancStone::BasicFetchingStrategy& strategy)
56 {
57 for (unsigned int i = 0; i < strategy.GetItemsCount(); i++)
58 {
59 if (qualities_.find(i) == qualities_.end() ||
60 qualities_[i] != strategy.GetMaxQuality())
61 {
62 return false;
63 }
64 }
65
66 return true;
67 }
68 };
69 }
70
71
72 TEST(BasicFetchingStrategy, Test1)
73 {
74 ASSERT_THROW(OrthancStone::BasicFetchingStrategy(NULL, 0), Orthanc::OrthancException);
75 ASSERT_THROW(OrthancStone::BasicFetchingStrategy(new OrthancStone::BasicFetchingItemsSorter(0), 0), Orthanc::OrthancException);
76
77 {
78 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(1), 0);
79 unsigned int i, q;
80 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q);
81 ASSERT_FALSE(s.GetNext(i, q));
82 }
83
84 {
85 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(1), 5);
86 unsigned int i, q;
87 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(5u, q);
88 ASSERT_FALSE(s.GetNext(i, q));
89 }
90
91 {
92 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(2), 2);
93 unsigned int i, q;
94 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q);
95 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q);
96 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q);
97 ASSERT_FALSE(s.GetNext(i, q));
98 }
99
100 {
101 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(3), 2);
102 unsigned int i, q;
103 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q);
104 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q);
105 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(1u, q);
106 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q);
107 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(2u, q);
108 ASSERT_FALSE(s.GetNext(i, q));
109 }
110
111 {
112 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(3), 2);
113 s.SetBlockSize(1);
114 s.SetCurrent(0);
115 unsigned int i, q;
116 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q);
117 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q);
118 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q);
119 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q);
120 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(1u, q);
121 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(2u, q);
122 ASSERT_FALSE(s.GetNext(i, q));
123 }
124
125 {
126 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(5), 0);
127 ASSERT_THROW(s.SetCurrent(5), Orthanc::OrthancException);
128 s.SetCurrent(2);
129
130 unsigned int i, q;
131 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q);
132 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(3u, i); ASSERT_EQ(0u, q);
133 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(0u, q);
134 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(4u, i); ASSERT_EQ(0u, q);
135 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q);
136 ASSERT_FALSE(s.GetNext(i, q));
137 }
138
139 {
140 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(5), 0);
141 s.SetCurrent(4);
142
143 unsigned int i, q;
144 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(4u, i); ASSERT_EQ(0u, q);
145 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(3u, i); ASSERT_EQ(0u, q);
146 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q);
147 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(0u, q);
148 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q);
149 ASSERT_FALSE(s.GetNext(i, q));
150 }
151 }
152
153
154 TEST(BasicFetchingStrategy, Test2)
155 {
156 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(20), 2);
157 ASSERT_EQ(20u, s.GetItemsCount());
158 ASSERT_EQ(2u, s.GetMaxQuality());
159
160 StrategyTester t;
161
162 s.SetCurrent(10);
163
164 unsigned int i, q;
165 while (s.GetNext(i, q))
166 {
167 ASSERT_TRUE(t.IsValidCommand(i, q));
168 }
169
170 ASSERT_TRUE(t.HasFinished(s));
171 }
172
173
174
175
176 TEST(BasicFetchingItemsSorter, Small)
177 {
178 ASSERT_THROW(OrthancStone::BasicFetchingItemsSorter(0), Orthanc::OrthancException);
179 std::vector<unsigned int> v;
180
181 {
182 OrthancStone::BasicFetchingItemsSorter s(1);
183 s.Sort(v, 0);
184 ASSERT_EQ(1u, v.size());
185 ASSERT_EQ(0u, v[0]);
186
187 ASSERT_THROW(s.Sort(v, 1), Orthanc::OrthancException);
188 }
189
190 {
191 OrthancStone::BasicFetchingItemsSorter s(2);
192 s.Sort(v, 0);
193 ASSERT_EQ(2u, v.size());
194 ASSERT_EQ(0u, v[0]);
195 ASSERT_EQ(1u, v[1]);
196
197 s.Sort(v, 1);
198 ASSERT_EQ(2u, v.size());
199 ASSERT_EQ(1u, v[0]);
200 ASSERT_EQ(0u, v[1]);
201
202 ASSERT_THROW(s.Sort(v, 2), Orthanc::OrthancException);
203 }
204
205 {
206 OrthancStone::BasicFetchingItemsSorter s(3);
207 s.Sort(v, 0);
208 ASSERT_EQ(3u, v.size());
209 ASSERT_EQ(0u, v[0]);
210 ASSERT_EQ(1u, v[1]);
211 ASSERT_EQ(2u, v[2]);
212
213 s.Sort(v, 1);
214 ASSERT_EQ(3u, v.size());
215 ASSERT_EQ(1u, v[0]);
216 ASSERT_EQ(2u, v[1]);
217 ASSERT_EQ(0u, v[2]);
218
219 s.Sort(v, 2);
220 ASSERT_EQ(3u, v.size());
221 ASSERT_EQ(2u, v[0]);
222 ASSERT_EQ(1u, v[1]);
223 ASSERT_EQ(0u, v[2]);
224
225 ASSERT_THROW(s.Sort(v, 3), Orthanc::OrthancException);
226 }
227 }
228
229
230 TEST(BasicFetchingItemsSorter, Odd)
231 {
232 OrthancStone::BasicFetchingItemsSorter s(7);
233 std::vector<unsigned int> v;
234
235 ASSERT_THROW(s.Sort(v, 7), Orthanc::OrthancException);
236
237 {
238 s.Sort(v, 0);
239 ASSERT_EQ(7u, v.size());
240 ASSERT_EQ(0u, v[0]);
241 ASSERT_EQ(1u, v[1]);
242 ASSERT_EQ(2u, v[2]);
243 ASSERT_EQ(3u, v[3]);
244 ASSERT_EQ(4u, v[4]);
245 ASSERT_EQ(5u, v[5]);
246 ASSERT_EQ(6u, v[6]);
247 }
248
249 {
250 s.Sort(v, 1);
251 ASSERT_EQ(7u, v.size());
252 ASSERT_EQ(1u, v[0]);
253 ASSERT_EQ(2u, v[1]);
254 ASSERT_EQ(0u, v[2]);
255 ASSERT_EQ(3u, v[3]);
256 ASSERT_EQ(4u, v[4]);
257 ASSERT_EQ(5u, v[5]);
258 ASSERT_EQ(6u, v[6]);
259 }
260
261 {
262 s.Sort(v, 2);
263 ASSERT_EQ(7u, v.size());
264 ASSERT_EQ(2u, v[0]);
265 ASSERT_EQ(3u, v[1]);
266 ASSERT_EQ(1u, v[2]);
267 ASSERT_EQ(4u, v[3]);
268 ASSERT_EQ(0u, v[4]);
269 ASSERT_EQ(5u, v[5]);
270 ASSERT_EQ(6u, v[6]);
271 }
272
273 {
274 s.Sort(v, 3);
275 ASSERT_EQ(7u, v.size());
276 ASSERT_EQ(3u, v[0]);
277 ASSERT_EQ(4u, v[1]);
278 ASSERT_EQ(2u, v[2]);
279 ASSERT_EQ(5u, v[3]);
280 ASSERT_EQ(1u, v[4]);
281 ASSERT_EQ(6u, v[5]);
282 ASSERT_EQ(0u, v[6]);
283 }
284
285 {
286 s.Sort(v, 4);
287 ASSERT_EQ(7u, v.size());
288 ASSERT_EQ(4u, v[0]);
289 ASSERT_EQ(5u, v[1]);
290 ASSERT_EQ(3u, v[2]);
291 ASSERT_EQ(6u, v[3]);
292 ASSERT_EQ(2u, v[4]);
293 ASSERT_EQ(1u, v[5]);
294 ASSERT_EQ(0u, v[6]);
295 }
296
297 {
298 s.Sort(v, 5);
299 ASSERT_EQ(7u, v.size());
300 ASSERT_EQ(5u, v[0]);
301 ASSERT_EQ(6u, v[1]);
302 ASSERT_EQ(4u, v[2]);
303 ASSERT_EQ(3u, v[3]);
304 ASSERT_EQ(2u, v[4]);
305 ASSERT_EQ(1u, v[5]);
306 ASSERT_EQ(0u, v[6]);
307 }
308
309 {
310 s.Sort(v, 6);
311 ASSERT_EQ(7u, v.size());
312 ASSERT_EQ(6u, v[0]);
313 ASSERT_EQ(5u, v[1]);
314 ASSERT_EQ(4u, v[2]);
315 ASSERT_EQ(3u, v[3]);
316 ASSERT_EQ(2u, v[4]);
317 ASSERT_EQ(1u, v[5]);
318 ASSERT_EQ(0u, v[6]);
319 }
320 }
321
322
323 TEST(BasicFetchingItemsSorter, Even)
324 {
325 OrthancStone::BasicFetchingItemsSorter s(6);
326 std::vector<unsigned int> v;
327
328 {
329 s.Sort(v, 0);
330 ASSERT_EQ(6u, v.size());
331 ASSERT_EQ(0u, v[0]);
332 ASSERT_EQ(1u, v[1]);
333 ASSERT_EQ(2u, v[2]);
334 ASSERT_EQ(3u, v[3]);
335 ASSERT_EQ(4u, v[4]);
336 ASSERT_EQ(5u, v[5]);
337 }
338
339 {
340 s.Sort(v, 1);
341 ASSERT_EQ(6u, v.size());
342 ASSERT_EQ(1u, v[0]);
343 ASSERT_EQ(2u, v[1]);
344 ASSERT_EQ(0u, v[2]);
345 ASSERT_EQ(3u, v[3]);
346 ASSERT_EQ(4u, v[4]);
347 ASSERT_EQ(5u, v[5]);
348 }
349
350 {
351 s.Sort(v, 2);
352 ASSERT_EQ(6u, v.size());
353 ASSERT_EQ(2u, v[0]);
354 ASSERT_EQ(3u, v[1]);
355 ASSERT_EQ(1u, v[2]);
356 ASSERT_EQ(4u, v[3]);
357 ASSERT_EQ(0u, v[4]);
358 ASSERT_EQ(5u, v[5]);
359 }
360
361 {
362 s.Sort(v, 3);
363 ASSERT_EQ(6u, v.size());
364 ASSERT_EQ(3u, v[0]);
365 ASSERT_EQ(4u, v[1]);
366 ASSERT_EQ(2u, v[2]);
367 ASSERT_EQ(5u, v[3]);
368 ASSERT_EQ(1u, v[4]);
369 ASSERT_EQ(0u, v[5]);
370 }
371
372 {
373 s.Sort(v, 4);
374 ASSERT_EQ(6u, v.size());
375 ASSERT_EQ(4u, v[0]);
376 ASSERT_EQ(5u, v[1]);
377 ASSERT_EQ(3u, v[2]);
378 ASSERT_EQ(2u, v[3]);
379 ASSERT_EQ(1u, v[4]);
380 ASSERT_EQ(0u, v[5]);
381 }
382
383 {
384 s.Sort(v, 5);
385 ASSERT_EQ(6u, v.size());
386 ASSERT_EQ(5u, v[0]);
387 ASSERT_EQ(4u, v[1]);
388 ASSERT_EQ(3u, v[2]);
389 ASSERT_EQ(2u, v[3]);
390 ASSERT_EQ(1u, v[4]);
391 ASSERT_EQ(0u, v[5]);
392 }
393 }