Mercurial > hg > orthanc-stone
annotate UnitTestsSources/TestStrategy.cpp @ 697:14557e550920
BasicFetchingStrategy
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Sun, 19 May 2019 13:21:22 +0200 |
| parents | 7bf91c4ebd65 |
| children | 51976977d2d3 |
| rev | line source |
|---|---|
| 695 | 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-2019 Osimis S.A., Belgium | |
| 6 * | |
| 7 * This program is free software: you can redistribute it and/or | |
| 8 * modify it under the terms of the GNU Affero General Public License | |
| 9 * as published by the Free Software Foundation, either version 3 of | |
| 10 * the License, or (at your option) any later version. | |
| 11 * | |
| 12 * This program is distributed in the hope that it will be useful, but | |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 15 * Affero General Public License for more details. | |
| 16 * | |
| 17 * You should have received a copy of the GNU Affero General Public License | |
| 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 19 **/ | |
| 20 | |
| 21 | |
| 22 #include "gtest/gtest.h" | |
| 23 | |
| 24 #include <Core/OrthancException.h> | |
| 25 | |
| 26 #include <boost/noncopyable.hpp> | |
| 27 #include <vector> | |
| 28 | |
| 29 namespace OrthancStone | |
| 30 { | |
| 31 class IFetchingStrategy : public boost::noncopyable | |
| 32 { | |
| 33 public: | |
| 34 virtual ~IFetchingStrategy() | |
| 35 { | |
| 36 } | |
| 37 | |
| 38 virtual unsigned int GetItemsCount() const = 0; | |
| 39 | |
| 40 virtual unsigned int GetMaxQuality() const = 0; | |
| 41 | |
| 42 virtual bool GetNext(unsigned int& item, | |
| 43 unsigned int& quality) = 0; | |
| 44 | |
| 45 virtual void SetCurrent(unsigned int item) = 0; | |
| 46 | |
| 47 // Ask the strategy to re-schedule the item with the lowest | |
| 48 // priority in the fetching order. This allows to know which item | |
| 49 // should be dropped from a cache. | |
| 50 virtual void RecycleFurthest(unsigned int& item) = 0; | |
| 51 }; | |
| 52 | |
| 53 | |
| 54 class IFetchingItemsSorter : public boost::noncopyable | |
| 55 { | |
| 56 public: | |
| 57 virtual ~IFetchingItemsSorter() | |
| 58 { | |
| 59 } | |
| 60 | |
| 61 virtual unsigned int GetItemsCount() const = 0; | |
| 62 | |
| 63 // Sort a set of items given the current item | |
| 64 virtual void Sort(std::vector<unsigned int>& target, | |
| 65 unsigned int current) = 0; | |
| 66 }; | |
| 67 | |
| 68 | |
| 69 | |
| 70 class BasicFetchingItemsSorter : public IFetchingItemsSorter | |
| 71 { | |
| 72 private: | |
| 73 unsigned int itemsCount_; | |
| 74 | |
| 75 public: | |
| 76 BasicFetchingItemsSorter(unsigned int itemsCount) : | |
| 77 itemsCount_(itemsCount) | |
| 78 { | |
| 79 if (itemsCount == 0) | |
| 80 { | |
| 81 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 82 } | |
| 83 } | |
| 84 | |
| 85 virtual unsigned int GetItemsCount() const | |
| 86 { | |
| 87 return itemsCount_; | |
| 88 } | |
| 89 | |
| 90 virtual void Sort(std::vector<unsigned int>& target, | |
| 91 unsigned int current) | |
| 92 { | |
| 93 if (current >= itemsCount_) | |
| 94 { | |
| 95 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
| 96 } | |
| 97 | |
| 98 target.clear(); | |
| 99 target.reserve(itemsCount_); | |
| 100 target.push_back(current); | |
| 101 | |
| 102 const unsigned int countBelow = current; | |
| 103 const unsigned int countAbove = (itemsCount_ - 1) - current; | |
| 104 const unsigned int n = std::min(countBelow, countAbove); | |
| 105 | |
| 106 for (unsigned int i = 1; i <= n; i++) | |
| 107 { | |
| 108 assert(current + i < itemsCount_ && | |
| 109 current >= i); | |
| 110 target.push_back(current + i); | |
| 111 target.push_back(current - i); | |
| 112 } | |
| 113 | |
| 114 for (unsigned int i = current - n; i > 0; i--) | |
| 115 { | |
| 116 target.push_back(i - 1); | |
| 117 } | |
| 118 | |
| 119 for (unsigned int i = current + n + 1; i < itemsCount_; i++) | |
| 120 { | |
| 121 target.push_back(i); | |
| 122 } | |
| 123 | |
| 124 assert(target.size() == itemsCount_); | |
| 125 } | |
| 126 }; | |
| 127 | |
| 128 | |
| 129 class BasicFetchingStrategy : public IFetchingStrategy | |
| 130 { | |
| 131 private: | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
132 class ContentItem |
| 695 | 133 { |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
134 private: |
| 695 | 135 unsigned int item_; |
| 136 unsigned int quality_; | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
137 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
138 public: |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
139 ContentItem(unsigned int item, |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
140 unsigned int quality) : |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
141 item_(item), |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
142 quality_(quality) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
143 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
144 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
145 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
146 unsigned int GetItem() const |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
147 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
148 return item_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
149 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
150 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
151 unsigned int GetQuality() const |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
152 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
153 return quality_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
154 } |
| 695 | 155 }; |
| 156 | |
| 157 std::auto_ptr<IFetchingItemsSorter> sorter_; | |
| 158 std::vector<unsigned int> nextQuality_; | |
| 159 unsigned int maxQuality_; | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
160 std::vector<ContentItem> content_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
161 size_t position_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
162 unsigned int blockSize_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
163 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
164 void Schedule(unsigned int item, |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
165 unsigned int quality) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
166 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
167 assert(item < GetItemsCount() && |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
168 quality <= maxQuality_); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
169 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
170 if (nextQuality_[item] <= quality) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
171 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
172 content_.push_back(ContentItem(item, quality)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
173 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
174 } |
| 695 | 175 |
| 176 public: | |
| 177 BasicFetchingStrategy(IFetchingItemsSorter* sorter, // Takes ownership | |
| 178 unsigned int maxQuality) : | |
| 179 sorter_(sorter), | |
| 180 maxQuality_(maxQuality), | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
181 position_(0), |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
182 blockSize_(2) |
| 695 | 183 { |
| 184 if (sorter == NULL) | |
| 185 { | |
| 186 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
| 187 } | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
188 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
189 nextQuality_.resize(sorter_->GetItemsCount(), 0), // Does not change along calls to "SetCurrent()" |
| 695 | 190 |
| 191 SetCurrent(0); | |
| 192 } | |
| 193 | |
| 194 virtual unsigned int GetItemsCount() const | |
| 195 { | |
| 196 return sorter_->GetItemsCount(); | |
| 197 } | |
| 198 | |
| 199 virtual unsigned int GetMaxQuality() const | |
| 200 { | |
| 201 return maxQuality_; | |
| 202 } | |
| 203 | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
204 void SetBlockSize(unsigned int size) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
205 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
206 if (size <= 0) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
207 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
208 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
209 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
210 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
211 blockSize_ = size; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
212 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
213 |
| 695 | 214 virtual bool GetNext(unsigned int& item, |
| 215 unsigned int& quality) | |
| 216 { | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
217 if (position_ >= content_.size()) |
| 695 | 218 { |
| 219 return false; | |
| 220 } | |
| 221 else | |
| 222 { | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
223 item = content_[position_].GetItem(); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
224 quality = content_[position_].GetQuality(); |
| 695 | 225 |
| 226 assert(nextQuality_[item] <= quality); | |
| 227 nextQuality_[item] = quality + 1; | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
228 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
229 position_ ++; |
| 695 | 230 return true; |
| 231 } | |
| 232 } | |
| 233 | |
| 234 virtual void SetCurrent(unsigned int item) | |
| 235 { | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
236 // TODO - This function is O(N) complexity where "N" is the |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
237 // number of items times the max quality. Could use a LRU index. |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
238 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
239 position_ = 0; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
240 |
| 695 | 241 std::vector<unsigned int> v; |
| 242 sorter_->Sort(v, item); | |
| 243 | |
| 244 assert(v.size() == GetItemsCount()); | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
245 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
246 if (v.size() == 0) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
247 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
248 return; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
249 } |
| 695 | 250 |
| 251 content_.clear(); | |
| 252 content_.reserve(v.size() * maxQuality_); | |
| 253 | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
254 Schedule(v.front(), maxQuality_); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
255 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
256 for (unsigned int q = 0; q <= maxQuality_; q++) |
| 695 | 257 { |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
258 unsigned int start = 1 + q * blockSize_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
259 unsigned int end = start + blockSize_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
260 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
261 if (q == maxQuality_ || |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
262 end > v.size()) |
| 695 | 263 { |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
264 end = v.size(); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
265 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
266 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
267 unsigned int a = 0; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
268 if (maxQuality_ >= q + 1) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
269 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
270 a = maxQuality_ - q - 1; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
271 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
272 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
273 for (unsigned int j = a; j <= maxQuality_; j++) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
274 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
275 for (unsigned int i = start; i < end; i++) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
276 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
277 Schedule(v[i], j); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
278 } |
| 695 | 279 } |
| 280 } | |
| 281 } | |
| 282 | |
| 283 // Ask the strategy to re-schedule the item with the lowest | |
| 284 // priority in the fetching order. This allows to know which item | |
| 285 // should be dropped from a cache. | |
| 286 virtual void RecycleFurthest(unsigned int& item) | |
| 287 { | |
| 288 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 289 } | |
| 290 }; | |
| 291 } | |
| 292 | |
| 293 | |
| 294 | |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
295 namespace |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
296 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
297 class StrategyTester : public boost::noncopyable |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
298 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
299 private: |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
300 std::map<unsigned int, unsigned int> qualities_; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
301 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
302 public: |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
303 bool IsValidCommand(unsigned int item, |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
304 unsigned int quality) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
305 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
306 if (qualities_.find(item) != qualities_.end() && |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
307 qualities_[item] >= quality) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
308 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
309 return false; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
310 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
311 else |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
312 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
313 qualities_[item] = quality; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
314 return true; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
315 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
316 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
317 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
318 bool HasFinished(OrthancStone::BasicFetchingStrategy& strategy) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
319 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
320 for (unsigned int i = 0; i < strategy.GetItemsCount(); i++) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
321 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
322 if (qualities_.find(i) == qualities_.end() || |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
323 qualities_[i] != strategy.GetMaxQuality()) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
324 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
325 return false; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
326 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
327 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
328 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
329 return true; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
330 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
331 }; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
332 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
333 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
334 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
335 TEST(BasicFetchingStrategy, Test1) |
| 695 | 336 { |
|
697
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
337 ASSERT_THROW(OrthancStone::BasicFetchingStrategy(NULL, 0), Orthanc::OrthancException); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
338 ASSERT_THROW(OrthancStone::BasicFetchingStrategy(new OrthancStone::BasicFetchingItemsSorter(0), 0), Orthanc::OrthancException); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
339 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
340 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
341 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(1), 0); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
342 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
343 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
344 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
345 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
346 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
347 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
348 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(1), 5); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
349 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
350 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(5u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
351 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
352 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
353 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
354 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
355 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(2), 2); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
356 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
357 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
358 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
359 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
360 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
361 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
362 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
363 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
364 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(3), 2); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
365 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
366 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
367 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
368 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(1u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
369 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
370 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
371 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
372 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
373 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
374 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
375 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(3), 2); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
376 s.SetBlockSize(1); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
377 s.SetCurrent(0); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
378 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
379 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
380 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(1u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
381 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
382 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
383 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(1u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
384 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(2u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
385 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
386 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
387 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
388 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
389 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(5), 0); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
390 ASSERT_THROW(s.SetCurrent(5), Orthanc::OrthancException); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
391 s.SetCurrent(2); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
392 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
393 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
394 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
395 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(3u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
396 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
397 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(4u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
398 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
399 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
400 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
401 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
402 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
403 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(5), 0); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
404 s.SetCurrent(4); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
405 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
406 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
407 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(4u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
408 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(3u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
409 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(2u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
410 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(1u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
411 ASSERT_TRUE(s.GetNext(i, q)); ASSERT_EQ(0u, i); ASSERT_EQ(0u, q); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
412 ASSERT_FALSE(s.GetNext(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
413 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
414 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
415 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
416 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
417 TEST(BasicFetchingStrategy, Test2) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
418 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
419 OrthancStone::BasicFetchingStrategy s(new OrthancStone::BasicFetchingItemsSorter(20), 2); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
420 ASSERT_EQ(20u, s.GetItemsCount()); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
421 ASSERT_EQ(2u, s.GetMaxQuality()); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
422 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
423 StrategyTester t; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
424 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
425 s.SetCurrent(10); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
426 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
427 unsigned int i, q; |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
428 while (s.GetNext(i, q)) |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
429 { |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
430 ASSERT_TRUE(t.IsValidCommand(i, q)); |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
431 } |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
432 |
|
14557e550920
BasicFetchingStrategy
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
695
diff
changeset
|
433 ASSERT_TRUE(t.HasFinished(s)); |
| 695 | 434 } |
| 435 | |
| 436 | |
| 437 | |
| 438 | |
| 439 TEST(BasicFetchingItemsSorter, Small) | |
| 440 { | |
| 441 ASSERT_THROW(OrthancStone::BasicFetchingItemsSorter(0), Orthanc::OrthancException); | |
| 442 std::vector<unsigned int> v; | |
| 443 | |
| 444 { | |
| 445 OrthancStone::BasicFetchingItemsSorter s(1); | |
| 446 s.Sort(v, 0); | |
| 447 ASSERT_EQ(1u, v.size()); | |
| 448 ASSERT_EQ(0u, v[0]); | |
| 449 | |
| 450 ASSERT_THROW(s.Sort(v, 1), Orthanc::OrthancException); | |
| 451 } | |
| 452 | |
| 453 { | |
| 454 OrthancStone::BasicFetchingItemsSorter s(2); | |
| 455 s.Sort(v, 0); | |
| 456 ASSERT_EQ(2u, v.size()); | |
| 457 ASSERT_EQ(0u, v[0]); | |
| 458 ASSERT_EQ(1u, v[1]); | |
| 459 | |
| 460 s.Sort(v, 1); | |
| 461 ASSERT_EQ(2u, v.size()); | |
| 462 ASSERT_EQ(1u, v[0]); | |
| 463 ASSERT_EQ(0u, v[1]); | |
| 464 | |
| 465 ASSERT_THROW(s.Sort(v, 2), Orthanc::OrthancException); | |
| 466 } | |
| 467 | |
| 468 { | |
| 469 OrthancStone::BasicFetchingItemsSorter s(3); | |
| 470 s.Sort(v, 0); | |
| 471 ASSERT_EQ(3u, v.size()); | |
| 472 ASSERT_EQ(0u, v[0]); | |
| 473 ASSERT_EQ(1u, v[1]); | |
| 474 ASSERT_EQ(2u, v[2]); | |
| 475 | |
| 476 s.Sort(v, 1); | |
| 477 ASSERT_EQ(3u, v.size()); | |
| 478 ASSERT_EQ(1u, v[0]); | |
| 479 ASSERT_EQ(2u, v[1]); | |
| 480 ASSERT_EQ(0u, v[2]); | |
| 481 | |
| 482 s.Sort(v, 2); | |
| 483 ASSERT_EQ(3u, v.size()); | |
| 484 ASSERT_EQ(2u, v[0]); | |
| 485 ASSERT_EQ(1u, v[1]); | |
| 486 ASSERT_EQ(0u, v[2]); | |
| 487 | |
| 488 ASSERT_THROW(s.Sort(v, 3), Orthanc::OrthancException); | |
| 489 } | |
| 490 } | |
| 491 | |
| 492 | |
| 493 TEST(BasicFetchingItemsSorter, Odd) | |
| 494 { | |
| 495 OrthancStone::BasicFetchingItemsSorter s(7); | |
| 496 std::vector<unsigned int> v; | |
| 497 | |
| 498 ASSERT_THROW(s.Sort(v, 7), Orthanc::OrthancException); | |
| 499 | |
| 500 { | |
| 501 s.Sort(v, 0); | |
| 502 ASSERT_EQ(7u, v.size()); | |
| 503 ASSERT_EQ(0u, v[0]); | |
| 504 ASSERT_EQ(1u, v[1]); | |
| 505 ASSERT_EQ(2u, v[2]); | |
| 506 ASSERT_EQ(3u, v[3]); | |
| 507 ASSERT_EQ(4u, v[4]); | |
| 508 ASSERT_EQ(5u, v[5]); | |
| 509 ASSERT_EQ(6u, v[6]); | |
| 510 } | |
| 511 | |
| 512 { | |
| 513 s.Sort(v, 1); | |
| 514 ASSERT_EQ(7u, v.size()); | |
| 515 ASSERT_EQ(1u, v[0]); | |
| 516 ASSERT_EQ(2u, v[1]); | |
| 517 ASSERT_EQ(0u, v[2]); | |
| 518 ASSERT_EQ(3u, v[3]); | |
| 519 ASSERT_EQ(4u, v[4]); | |
| 520 ASSERT_EQ(5u, v[5]); | |
| 521 ASSERT_EQ(6u, v[6]); | |
| 522 } | |
| 523 | |
| 524 { | |
| 525 s.Sort(v, 2); | |
| 526 ASSERT_EQ(7u, v.size()); | |
| 527 ASSERT_EQ(2u, v[0]); | |
| 528 ASSERT_EQ(3u, v[1]); | |
| 529 ASSERT_EQ(1u, v[2]); | |
| 530 ASSERT_EQ(4u, v[3]); | |
| 531 ASSERT_EQ(0u, v[4]); | |
| 532 ASSERT_EQ(5u, v[5]); | |
| 533 ASSERT_EQ(6u, v[6]); | |
| 534 } | |
| 535 | |
| 536 { | |
| 537 s.Sort(v, 3); | |
| 538 ASSERT_EQ(7u, v.size()); | |
| 539 ASSERT_EQ(3u, v[0]); | |
| 540 ASSERT_EQ(4u, v[1]); | |
| 541 ASSERT_EQ(2u, v[2]); | |
| 542 ASSERT_EQ(5u, v[3]); | |
| 543 ASSERT_EQ(1u, v[4]); | |
| 544 ASSERT_EQ(6u, v[5]); | |
| 545 ASSERT_EQ(0u, v[6]); | |
| 546 } | |
| 547 | |
| 548 { | |
| 549 s.Sort(v, 4); | |
| 550 ASSERT_EQ(7u, v.size()); | |
| 551 ASSERT_EQ(4u, v[0]); | |
| 552 ASSERT_EQ(5u, v[1]); | |
| 553 ASSERT_EQ(3u, v[2]); | |
| 554 ASSERT_EQ(6u, v[3]); | |
| 555 ASSERT_EQ(2u, v[4]); | |
| 556 ASSERT_EQ(1u, v[5]); | |
| 557 ASSERT_EQ(0u, v[6]); | |
| 558 } | |
| 559 | |
| 560 { | |
| 561 s.Sort(v, 5); | |
| 562 ASSERT_EQ(7u, v.size()); | |
| 563 ASSERT_EQ(5u, v[0]); | |
| 564 ASSERT_EQ(6u, v[1]); | |
| 565 ASSERT_EQ(4u, v[2]); | |
| 566 ASSERT_EQ(3u, v[3]); | |
| 567 ASSERT_EQ(2u, v[4]); | |
| 568 ASSERT_EQ(1u, v[5]); | |
| 569 ASSERT_EQ(0u, v[6]); | |
| 570 } | |
| 571 | |
| 572 { | |
| 573 s.Sort(v, 6); | |
| 574 ASSERT_EQ(7u, v.size()); | |
| 575 ASSERT_EQ(6u, v[0]); | |
| 576 ASSERT_EQ(5u, v[1]); | |
| 577 ASSERT_EQ(4u, v[2]); | |
| 578 ASSERT_EQ(3u, v[3]); | |
| 579 ASSERT_EQ(2u, v[4]); | |
| 580 ASSERT_EQ(1u, v[5]); | |
| 581 ASSERT_EQ(0u, v[6]); | |
| 582 } | |
| 583 } | |
| 584 | |
| 585 | |
| 586 TEST(BasicFetchingItemsSorter, Even) | |
| 587 { | |
| 588 OrthancStone::BasicFetchingItemsSorter s(6); | |
| 589 std::vector<unsigned int> v; | |
| 590 | |
| 591 { | |
| 592 s.Sort(v, 0); | |
| 593 ASSERT_EQ(6u, v.size()); | |
| 594 ASSERT_EQ(0u, v[0]); | |
| 595 ASSERT_EQ(1u, v[1]); | |
| 596 ASSERT_EQ(2u, v[2]); | |
| 597 ASSERT_EQ(3u, v[3]); | |
| 598 ASSERT_EQ(4u, v[4]); | |
| 599 ASSERT_EQ(5u, v[5]); | |
| 600 } | |
| 601 | |
| 602 { | |
| 603 s.Sort(v, 1); | |
| 604 ASSERT_EQ(6u, v.size()); | |
| 605 ASSERT_EQ(1u, v[0]); | |
| 606 ASSERT_EQ(2u, v[1]); | |
| 607 ASSERT_EQ(0u, v[2]); | |
| 608 ASSERT_EQ(3u, v[3]); | |
| 609 ASSERT_EQ(4u, v[4]); | |
| 610 ASSERT_EQ(5u, v[5]); | |
| 611 } | |
| 612 | |
| 613 { | |
| 614 s.Sort(v, 2); | |
| 615 ASSERT_EQ(6u, v.size()); | |
| 616 ASSERT_EQ(2u, v[0]); | |
| 617 ASSERT_EQ(3u, v[1]); | |
| 618 ASSERT_EQ(1u, v[2]); | |
| 619 ASSERT_EQ(4u, v[3]); | |
| 620 ASSERT_EQ(0u, v[4]); | |
| 621 ASSERT_EQ(5u, v[5]); | |
| 622 } | |
| 623 | |
| 624 { | |
| 625 s.Sort(v, 3); | |
| 626 ASSERT_EQ(6u, v.size()); | |
| 627 ASSERT_EQ(3u, v[0]); | |
| 628 ASSERT_EQ(4u, v[1]); | |
| 629 ASSERT_EQ(2u, v[2]); | |
| 630 ASSERT_EQ(5u, v[3]); | |
| 631 ASSERT_EQ(1u, v[4]); | |
| 632 ASSERT_EQ(0u, v[5]); | |
| 633 } | |
| 634 | |
| 635 { | |
| 636 s.Sort(v, 4); | |
| 637 ASSERT_EQ(6u, v.size()); | |
| 638 ASSERT_EQ(4u, v[0]); | |
| 639 ASSERT_EQ(5u, v[1]); | |
| 640 ASSERT_EQ(3u, v[2]); | |
| 641 ASSERT_EQ(2u, v[3]); | |
| 642 ASSERT_EQ(1u, v[4]); | |
| 643 ASSERT_EQ(0u, v[5]); | |
| 644 } | |
| 645 | |
| 646 { | |
| 647 s.Sort(v, 5); | |
| 648 ASSERT_EQ(6u, v.size()); | |
| 649 ASSERT_EQ(5u, v[0]); | |
| 650 ASSERT_EQ(4u, v[1]); | |
| 651 ASSERT_EQ(3u, v[2]); | |
| 652 ASSERT_EQ(2u, v[3]); | |
| 653 ASSERT_EQ(1u, v[4]); | |
| 654 ASSERT_EQ(0u, v[5]); | |
| 655 } | |
| 656 } |