blob: 41082c6c89fba512e7a2d23f44b474213d8b36ff [file] [log] [blame]
Jiewen Tan99135962014-09-20 02:18:53 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Davide Pesavento10b24be2017-07-12 23:23:46 -04002/*
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -08003 * Copyright (c) 2013-2017 Regents of the University of California.
Jiewen Tan99135962014-09-20 02:18:53 -07004 *
5 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
6 *
7 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8 * terms of the GNU Lesser General Public License as published by the Free Software
9 * Foundation, either version 3 of the License, or (at your option) any later version.
10 *
11 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14 *
15 * You should have received copies of the GNU General Public License and GNU Lesser
16 * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17 * <http://www.gnu.org/licenses/>.
18 *
19 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
20 */
21
Junxiao Shic542f632017-07-18 14:20:32 +000022#include "ims/in-memory-storage.hpp"
23#include "ims/in-memory-storage-fifo.hpp"
24#include "ims/in-memory-storage-lfu.hpp"
25#include "ims/in-memory-storage-lru.hpp"
26#include "ims/in-memory-storage-persistent.hpp"
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -080027#include "security/signature-sha256-with-rsa.hpp"
Junxiao Shi6938e342017-07-25 21:56:58 +000028#include "util/sha256.hpp"
Jiewen Tan99135962014-09-20 02:18:53 -070029
30#include "boost-test.hpp"
Spyridon Mastorakis429634f2015-02-19 17:35:33 -080031#include "../make-interest-data.hpp"
Yingdi Yu404eafd2016-03-06 14:54:25 -080032#include "../unit-test-time-fixture.hpp"
Jiewen Tan99135962014-09-20 02:18:53 -070033
34#include <boost/mpl/list.hpp>
35
36namespace ndn {
Junxiao Shi85d90832016-08-04 03:19:46 +000037namespace tests {
Jiewen Tan99135962014-09-20 02:18:53 -070038
Junxiao Shi85d90832016-08-04 03:19:46 +000039using namespace ndn::tests;
Alexander Afanasyev3ccc6f72014-10-12 12:19:09 -070040
Junxiao Shic542f632017-07-18 14:20:32 +000041BOOST_AUTO_TEST_SUITE(Ims)
Junxiao Shi85d90832016-08-04 03:19:46 +000042BOOST_AUTO_TEST_SUITE(TestInMemoryStorage)
Alexander Afanasyev3ccc6f72014-10-12 12:19:09 -070043
Davide Pesaventoeee3e822016-11-26 19:19:34 +010044using InMemoryStorages = boost::mpl::list<InMemoryStoragePersistent,
45 InMemoryStorageFifo,
46 InMemoryStorageLfu,
47 InMemoryStorageLru>;
Jiewen Tan99135962014-09-20 02:18:53 -070048
Jiewen Tan99135962014-09-20 02:18:53 -070049BOOST_AUTO_TEST_CASE_TEMPLATE(Insertion, T, InMemoryStorages)
50{
51 T ims;
52
Jiewen Tan99135962014-09-20 02:18:53 -070053 ims.insert(*makeData("/a"));
54 ims.insert(*makeData("/b"));
55 ims.insert(*makeData("/c"));
56 ims.insert(*makeData("/d"));
57
58 BOOST_CHECK_EQUAL(ims.size(), 4);
59}
60
Davide Pesaventoeee3e822016-11-26 19:19:34 +010061BOOST_AUTO_TEST_CASE_TEMPLATE(Insertion2, T, InMemoryStorages)
Jiewen Tan99135962014-09-20 02:18:53 -070062{
63 T ims;
64
65 Name name("/a");
66
67 uint32_t content1 = 1;
68 shared_ptr<Data> data1 = makeData(name);
69 data1->setFreshnessPeriod(time::milliseconds(99999));
70 data1->setContent(reinterpret_cast<const uint8_t*>(&content1), sizeof(content1));
71 signData(data1);
72 ims.insert(*data1);
73
74 uint32_t content2 = 2;
75 shared_ptr<Data> data2 = makeData(name);
76 data2->setFreshnessPeriod(time::milliseconds(99999));
77 data2->setContent(reinterpret_cast<const uint8_t*>(&content2), sizeof(content2));
78 signData(data2);
79 ims.insert(*data2);
80
81 BOOST_CHECK_EQUAL(ims.size(), 2);
82}
83
84BOOST_AUTO_TEST_CASE_TEMPLATE(DuplicateInsertion, T, InMemoryStorages)
85{
86 T ims;
87
88 shared_ptr<Data> data0 = makeData("/insert/smth");
89 ims.insert(*data0);
90
91 shared_ptr<Data> data = makeData("/insert/duplicate");
92 ims.insert(*data);
93
94 ims.insert(*data);
95 BOOST_CHECK_EQUAL(ims.size(), 2);
96}
97
98BOOST_AUTO_TEST_CASE_TEMPLATE(DuplicateInsertion2, T, InMemoryStorages)
99{
100 T ims;
101
102 shared_ptr<Data> data = makeData("/insert/duplicate");
103 ims.insert(*data);
104
105 ims.insert(*data);
106 BOOST_CHECK_EQUAL(ims.size(), 1);
107
108 shared_ptr<Data> data2 = makeData("/insert/original");
109 ims.insert(*data2);
110 BOOST_CHECK_EQUAL(ims.size(), 2);
111}
112
113BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndFind, T, InMemoryStorages)
114{
115 T ims;
116
117 Name name("/insert/and/find");
118
119 shared_ptr<Data> data = makeData(name);
120 ims.insert(*data);
121
122 shared_ptr<Interest> interest = makeInterest(name);
123
124 shared_ptr<const Data> found = ims.find(*interest);
Junxiao Shi85d90832016-08-04 03:19:46 +0000125 BOOST_CHECK(found != nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700126 BOOST_CHECK_EQUAL(data->getName(), found->getName());
127}
128
129BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndNotFind, T, InMemoryStorages)
130{
131 T ims;
132
133 Name name("/insert/and/find");
134 shared_ptr<Data> data = makeData(name);
135 ims.insert(*data);
136
137 Name name2("/not/find");
138 shared_ptr<Interest> interest = makeInterest(name2);
139
140 shared_ptr<const Data> found = ims.find(*interest);
141
142 BOOST_CHECK_EQUAL(found.get(), static_cast<const Data*>(0));
143}
144
145BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndFindByName, T, InMemoryStorages)
146{
147 T ims;
148
149 Name name("/insert/and/find");
150
151 shared_ptr<Data> data = makeData(name);
152 ims.insert(*data);
153
154 shared_ptr<const Data> found = ims.find(name);
Junxiao Shi85d90832016-08-04 03:19:46 +0000155 BOOST_CHECK(found != nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700156 BOOST_CHECK_EQUAL(data->getName(), found->getName());
157}
158
159BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndFindByFullName, T, InMemoryStorages)
160{
161 T ims;
162
163 Name name("/insert/and/find");
164
165 shared_ptr<Data> data = makeData(name);
166 ims.insert(*data);
167
168 shared_ptr<const Data> found = ims.find(data->getFullName());
Junxiao Shi85d90832016-08-04 03:19:46 +0000169 BOOST_CHECK(found != nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700170 BOOST_CHECK_EQUAL(data->getFullName(), found->getFullName());
171}
172
173BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndNotFindByName, T, InMemoryStorages)
174{
175 T ims;
176
177 Name name("/insert/and/find");
178 shared_ptr<Data> data = makeData(name);
179 ims.insert(*data);
180
181 Name name2("/not/find");
182
183 shared_ptr<const Data> found = ims.find(name2);
Junxiao Shi85d90832016-08-04 03:19:46 +0000184 BOOST_CHECK(found == nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700185}
186
187BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndNotFindByFullName, T, InMemoryStorages)
188{
189 T ims;
190
191 Name name("/a");
192 uint32_t content1 = 1;
193 shared_ptr<Data> data1 = makeData(name);
194 data1->setContent(reinterpret_cast<const uint8_t*>(&content1), sizeof(content1));
195 signData(data1);
196 ims.insert(*data1);
197
198 uint32_t content2 = 2;
199 shared_ptr<Data> data2 = makeData(name);
200 data2->setContent(reinterpret_cast<const uint8_t*>(&content2), sizeof(content2));
201 signData(data2);
202
203 shared_ptr<const Data> found = ims.find(data2->getFullName());
Junxiao Shi85d90832016-08-04 03:19:46 +0000204 BOOST_CHECK(found == nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700205}
206
207BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEraseByName, T, InMemoryStorages)
208{
209 T ims;
210
211 Name name("/insertandremovebyname");
212
213 uint32_t content1 = 1;
214 shared_ptr<Data> data1 = makeData(name);
215 data1->setFreshnessPeriod(time::milliseconds(99999));
216 data1->setContent(reinterpret_cast<const uint8_t*>(&content1), sizeof(content1));
217 signData(data1);
218 ims.insert(*data1);
219
220 uint32_t content2 = 2;
221 shared_ptr<Data> data2 = makeData(name);
222 data2->setFreshnessPeriod(time::milliseconds(99999));
223 data2->setContent(reinterpret_cast<const uint8_t*>(&content2), sizeof(content2));
224 signData(data2);
225 ims.insert(*data2);
226
227 shared_ptr<Data> data3 = makeData("/insertandremovebyname/1");
228 ims.insert(*data3);
229
230 shared_ptr<Data> data4 = makeData("/insertandremovebyname/2");
231 ims.insert(*data4);
232
233 BOOST_CHECK_EQUAL(ims.size(), 4);
234
235 ims.erase(data1->getFullName(), false);
236 BOOST_CHECK_EQUAL(ims.size(), 3);
237}
238
239BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEraseByPrefix, T, InMemoryStorages)
240{
241 T ims;
242
243 shared_ptr<Data> data = makeData("/a");
244 ims.insert(*data);
245
246 shared_ptr<Data> data2 = makeData("/b");
247 ims.insert(*data2);
248
249 shared_ptr<Data> data3 = makeData("/c");
250 ims.insert(*data3);
251
252 shared_ptr<Data> data4 = makeData("/d");
253 ims.insert(*data4);
254
255 shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
256 ims.insert(*data5);
257
258 shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
259 ims.insert(*data6);
260
261 shared_ptr<Data> data7 = makeData("/c/c/1");
262 ims.insert(*data7);
263
264 BOOST_CHECK_EQUAL(ims.size(), 7);
265
266 Name name("/c");
267 ims.erase(name);
268 BOOST_CHECK_EQUAL(ims.size(), 3);
269 BOOST_CHECK_EQUAL(ims.getCapacity(), 5);
270}
271
272BOOST_AUTO_TEST_CASE_TEMPLATE(DigestCalculation, T, InMemoryStorages)
273{
274 shared_ptr<Data> data = makeData("/digest/compute");
275
Junxiao Shic542f632017-07-18 14:20:32 +0000276 ConstBufferPtr digest1 = util::Sha256::computeDigest(data->wireEncode().wire(), data->wireEncode().size());
Jiewen Tan99135962014-09-20 02:18:53 -0700277 BOOST_CHECK_EQUAL(digest1->size(), 32);
278
Alexander Afanasyev3e2c3a02017-01-19 13:55:56 -0800279 InMemoryStorageEntry entry;
280 entry.setData(*data);
Jiewen Tan99135962014-09-20 02:18:53 -0700281
282 BOOST_CHECK_EQUAL_COLLECTIONS(digest1->begin(), digest1->end(),
Alexander Afanasyev3e2c3a02017-01-19 13:55:56 -0800283 entry.getFullName()[-1].value_begin(),
284 entry.getFullName()[-1].value_end());
Jiewen Tan99135962014-09-20 02:18:53 -0700285}
286
287BOOST_AUTO_TEST_CASE_TEMPLATE(Iterator, T, InMemoryStorages)
288{
289 T ims;
290
291 BOOST_CONCEPT_ASSERT((boost::InputIterator<InMemoryStorage::const_iterator>));
292
293 for (int i = 0; i < 10; i++) {
294 std::ostringstream convert;
295 convert << i;
296 Name name("/" + convert.str());
297 shared_ptr<Data> data = makeData(name);
298 ims.insert(*data);
299 }
300
301 InMemoryStorage::const_iterator it = ims.begin();
302 InMemoryStorage::const_iterator tmp1 = it;
303 BOOST_REQUIRE(tmp1 == it);
304 InMemoryStorage::const_iterator tmp2 = tmp1++;
305 BOOST_REQUIRE(tmp2 != tmp1);
306 tmp2 = ++tmp1;
307 BOOST_REQUIRE(tmp2 == tmp1);
308
309 int i = 0;
310 for (;it != ims.end(); it++) {
311 std::ostringstream convert;
312 convert << i;
313 Name name("/" + convert.str());
314 BOOST_CHECK_EQUAL(it->getName(), name);
315 BOOST_CHECK_EQUAL((*it).getName(), name);
316 i++;
317 }
318}
319
320BOOST_AUTO_TEST_CASE_TEMPLATE(InsertCanonical, T, InMemoryStorages)
321{
322 T ims;
323
324 shared_ptr<Data> data = makeData("/a");
325 ims.insert(*data);
326
327 shared_ptr<Data> data2 = makeData("/b");
328 ims.insert(*data2);
329
330 shared_ptr<Data> data3 = makeData("/c");
331 ims.insert(*data3);
332
333 shared_ptr<Data> data4 = makeData("/d");
334 ims.insert(*data4);
335
336 shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
337 ims.insert(*data5);
338
339 shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
340 ims.insert(*data6);
341
342 shared_ptr<Data> data7 = makeData("/c/c/1");
343 ims.insert(*data7);
Davide Pesaventoeee3e822016-11-26 19:19:34 +0100344
345 // avoid "test case [...] did not check any assertions" message from Boost.Test
346 BOOST_CHECK(true);
Jiewen Tan99135962014-09-20 02:18:53 -0700347}
348
349BOOST_AUTO_TEST_CASE_TEMPLATE(EraseCanonical, T, InMemoryStorages)
350{
351 T ims;
352
353 shared_ptr<Data> data = makeData("/a");
354 ims.insert(*data);
355
356 shared_ptr<Data> data2 = makeData("/b");
357 ims.insert(*data2);
358
359 shared_ptr<Data> data3 = makeData("/c");
360 ims.insert(*data3);
361
362 shared_ptr<Data> data4 = makeData("/d");
363 ims.insert(*data4);
364
365 shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
366 ims.insert(*data5);
367
368 shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
369 ims.insert(*data6);
370
371 shared_ptr<Data> data7 = makeData("/c/c/1");
372 ims.insert(*data7);
373
Junxiao Shic542f632017-07-18 14:20:32 +0000374 ConstBufferPtr digest1 = util::Sha256::computeDigest(data->wireEncode().wire(), data->wireEncode().size());
Jiewen Tan99135962014-09-20 02:18:53 -0700375
376 Name name("/a");
377 ims.erase(name);
378 BOOST_CHECK_EQUAL(ims.size(), 6);
379}
380
Alexander Afanasyev56860f52014-11-07 11:51:17 -0800381BOOST_AUTO_TEST_CASE_TEMPLATE(ImplicitDigestSelector, T, InMemoryStorages)
Jiewen Tan99135962014-09-20 02:18:53 -0700382{
383 T ims;
384
385 Name name("/digest/works");
386 shared_ptr<Data> data = makeData(name);
387 ims.insert(*data);
388
389 shared_ptr<Data> data2 = makeData("/a");
390 ims.insert(*data2);
391
392 shared_ptr<Data> data3 = makeData("/z/z/z");
393 ims.insert(*data3);
394
Junxiao Shic542f632017-07-18 14:20:32 +0000395 ConstBufferPtr digest1 = util::Sha256::computeDigest(data->wireEncode().wire(), data->wireEncode().size());
Jiewen Tan99135962014-09-20 02:18:53 -0700396
397 shared_ptr<Interest> interest = makeInterest("");
Alexander Afanasyev56860f52014-11-07 11:51:17 -0800398 interest->setName(Name(name).appendImplicitSha256Digest(digest1->buf(), digest1->size()));
Jiewen Tan99135962014-09-20 02:18:53 -0700399 interest->setMinSuffixComponents(0);
400 interest->setMaxSuffixComponents(0);
401
402 shared_ptr<const Data> found = ims.find(*interest);
Junxiao Shi85d90832016-08-04 03:19:46 +0000403 BOOST_REQUIRE(found != nullptr);
Alexander Afanasyev56860f52014-11-07 11:51:17 -0800404 BOOST_CHECK_EQUAL(found->getName(), name);
405
406 shared_ptr<Interest> interest2 = makeInterest("");
407 uint8_t digest2[32] = {0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
408 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
409 interest2->setName(Name(name).appendImplicitSha256Digest(digest2, 32));
410 interest2->setMinSuffixComponents(0);
411 interest2->setMaxSuffixComponents(0);
412
413 shared_ptr<const Data> notfound = ims.find(*interest2);
Junxiao Shi85d90832016-08-04 03:19:46 +0000414 BOOST_CHECK(notfound == nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700415}
416
417BOOST_AUTO_TEST_CASE_TEMPLATE(ChildSelector, T, InMemoryStorages)
418{
419 T ims;
420
421 shared_ptr<Data> data = makeData("/a");
422 ims.insert(*data);
423
424 shared_ptr<Data> data2 = makeData("/b");
425 ims.insert(*data2);
426
427 shared_ptr<Data> data4 = makeData("/d");
428 ims.insert(*data4);
429
430 shared_ptr<Data> data5 = makeData("/c/c");
431 ims.insert(*data5);
432
433 shared_ptr<Data> data6 = makeData("/c/f");
434 ims.insert(*data6);
435
436 shared_ptr<Data> data7 = makeData("/c/n");
437 ims.insert(*data7);
438
439 shared_ptr<Interest> interest = makeInterest("/c");
440 interest->setChildSelector(1);
441
442 shared_ptr<const Data> found = ims.find(*interest);
443 BOOST_CHECK_EQUAL(found->getName(), "/c/n");
444
445 shared_ptr<Interest> interest2 = makeInterest("/c");
446 interest2->setChildSelector(0);
447
448 shared_ptr<const Data> found2 = ims.find(*interest2);
449 BOOST_CHECK_EQUAL(found2->getName(), "/c/c");
450}
451
452BOOST_AUTO_TEST_CASE_TEMPLATE(ChildSelector2, T, InMemoryStorages)
453{
454 T ims;
455
456 shared_ptr<Data> data = makeData("/a/b/1");
457 ims.insert(*data);
458
459 shared_ptr<Data> data2 = makeData("/a/b/2");
460 ims.insert(*data2);
461
462 shared_ptr<Data> data3 = makeData("/a/z/1");
463 ims.insert(*data3);
464
465 shared_ptr<Data> data4 = makeData("/a/z/2");
466 ims.insert(*data4);
467
468 shared_ptr<Interest> interest = makeInterest("/a");
469 interest->setChildSelector(1);
470
471 shared_ptr<const Data> found = ims.find(*interest);
472 BOOST_CHECK_EQUAL(found->getName(), "/a/z/1");
473}
474
475BOOST_AUTO_TEST_CASE_TEMPLATE(PublisherKeySelector, T, InMemoryStorages)
476{
477 T ims;
478
479 Name name("/insert/withkey");
480 shared_ptr<Data> data = makeData(name);
481 ims.insert(*data);
482
483 shared_ptr<Interest> interest = makeInterest(name);
484 Name keyName("/somewhere/key");
485
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -0800486 KeyLocator locator(keyName);
Jiewen Tan99135962014-09-20 02:18:53 -0700487 interest->setPublisherPublicKeyLocator(locator);
488
489 shared_ptr<const Data> found = ims.find(*interest);
Junxiao Shi85d90832016-08-04 03:19:46 +0000490 BOOST_CHECK(found == nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700491}
492
493BOOST_AUTO_TEST_CASE_TEMPLATE(PublisherKeySelector2, T, InMemoryStorages)
494{
495 T ims;
496 Name name("/insert/withkey");
497 shared_ptr<Data> data = makeData(name);
498 ims.insert(*data);
499
500 Name name2("/insert/withkey2");
501 shared_ptr<Data> data2 = make_shared<Data>(name2);
502
503 Name keyName("/somewhere/key");
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -0800504 const KeyLocator locator(keyName);
Jiewen Tan99135962014-09-20 02:18:53 -0700505
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -0800506 SignatureSha256WithRsa fakeSignature;
Alexander Afanasyevd5c48e02015-06-24 11:58:14 -0700507 fakeSignature.setValue(makeEmptyBlock(tlv::SignatureValue));
Jiewen Tan99135962014-09-20 02:18:53 -0700508 fakeSignature.setKeyLocator(locator);
509 data2->setSignature(fakeSignature);
510 data2->wireEncode();
511
512 ims.insert(*data2);
513
514 shared_ptr<Interest> interest = makeInterest(name2);
515 interest->setPublisherPublicKeyLocator(locator);
516
517 shared_ptr<const Data> found = ims.find(*interest);
Junxiao Shi85d90832016-08-04 03:19:46 +0000518 BOOST_CHECK(found != nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700519 BOOST_CHECK_EQUAL(found->getName(), data2->getName());
520}
521
Alexander Afanasyev56860f52014-11-07 11:51:17 -0800522BOOST_AUTO_TEST_CASE_TEMPLATE(MinMaxComponentsSelector, T, InMemoryStorages)
Jiewen Tan99135962014-09-20 02:18:53 -0700523{
524 T ims;
525
526 shared_ptr<Data> data = makeData("/a");
527 ims.insert(*data);
528
529 shared_ptr<Data> data2 = makeData("/b");
530 ims.insert(*data2);
531
532 shared_ptr<Data> data4 = makeData("/d");
533 ims.insert(*data4);
534
535 shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
536 ims.insert(*data5);
537
538 shared_ptr<Data> data6 = makeData("/c/c/6/7/8/9");
539 ims.insert(*data6);
540
541 shared_ptr<Data> data7 = makeData("/c/c/1/2/3");
542 ims.insert(*data7);
543
544 shared_ptr<Data> data8 = makeData("/c/c/1");
545 ims.insert(*data8);
546
547 shared_ptr<Interest> interest = makeInterest("/c/c");
548 interest->setMinSuffixComponents(3);
549 interest->setChildSelector(0);
550
551 shared_ptr<const Data> found = ims.find(*interest);
Alexander Afanasyev56860f52014-11-07 11:51:17 -0800552 BOOST_CHECK_EQUAL(found->getName(), "/c/c/1/2/3");
Jiewen Tan99135962014-09-20 02:18:53 -0700553
554 shared_ptr<Interest> interest2 = makeInterest("/c/c");
555 interest2->setMinSuffixComponents(4);
556 interest2->setChildSelector(1);
557
558 shared_ptr<const Data> found2 = ims.find(*interest2);
559 BOOST_CHECK_EQUAL(found2->getName(), "/c/c/6/7/8/9");
560
561 shared_ptr<Interest> interest3 = makeInterest("/c/c");
562 interest3->setMaxSuffixComponents(2);
563 interest3->setChildSelector(1);
564
565 shared_ptr<const Data> found3 = ims.find(*interest3);
566 BOOST_CHECK_EQUAL(found3->getName(), "/c/c/1");
567}
568
569BOOST_AUTO_TEST_CASE_TEMPLATE(ExcludeSelector, T, InMemoryStorages)
570{
571 T ims;
572
573 shared_ptr<Data> data = makeData("/a");
574 ims.insert(*data);
575
576 shared_ptr<Data> data2 = makeData("/b");
577 ims.insert(*data2);
578
579 shared_ptr<Data> data3 = makeData("/c/a");
580 ims.insert(*data3);
581
582 shared_ptr<Data> data4 = makeData("/d");
583 ims.insert(*data4);
584
585 shared_ptr<Data> data5 = makeData("/c/c");
586 ims.insert(*data5);
587
588 shared_ptr<Data> data6 = makeData("/c/f");
589 ims.insert(*data6);
590
591 shared_ptr<Data> data7 = makeData("/c/n");
592 ims.insert(*data7);
593
594 shared_ptr<Interest> interest = makeInterest("/c");
595 interest->setChildSelector(1);
596 Exclude e;
597 e.excludeOne (Name::Component("n"));
598 interest->setExclude(e);
599
600 shared_ptr<const Data> found = ims.find(*interest);
601 BOOST_CHECK_EQUAL(found->getName(), "/c/f");
602
603 shared_ptr<Interest> interest2 = makeInterest("/c");
604 interest2->setChildSelector(0);
605
606 Exclude e2;
607 e2.excludeOne (Name::Component("a"));
608 interest2->setExclude(e2);
609
610 shared_ptr<const Data> found2 = ims.find(*interest2);
611 BOOST_CHECK_EQUAL(found2->getName(), "/c/c");
612
613 shared_ptr<Interest> interest3 = makeInterest("/c");
614 interest3->setChildSelector(0);
615
616 Exclude e3;
617 e3.excludeOne (Name::Component("c"));
618 interest3->setExclude(e3);
619
620 shared_ptr<const Data> found3 = ims.find(*interest3);
621 BOOST_CHECK_EQUAL(found3->getName(), "/c/a");
622}
623
Davide Pesaventoeee3e822016-11-26 19:19:34 +0100624using InMemoryStoragesLimited = boost::mpl::list<InMemoryStorageFifo,
625 InMemoryStorageLfu,
626 InMemoryStorageLru>;
Jiewen Tan99135962014-09-20 02:18:53 -0700627
Yingdi Yu404eafd2016-03-06 14:54:25 -0800628BOOST_AUTO_TEST_CASE_TEMPLATE(SetCapacity, T, InMemoryStoragesLimited)
Jiewen Tan99135962014-09-20 02:18:53 -0700629{
630 T ims;
631
632 ims.setCapacity(3);
633 ims.insert(*makeData("/1"));
634 ims.insert(*makeData("/2"));
635 ims.insert(*makeData("/3"));
636 BOOST_CHECK_EQUAL(ims.size(), 3);
637
638 ims.setCapacity(2);
639 BOOST_CHECK_EQUAL(ims.size(), 2);
640}
641
642BOOST_AUTO_TEST_CASE_TEMPLATE(GetLimit, T, InMemoryStoragesLimited)
643{
644 T ims(10000);
645
646 BOOST_CHECK_EQUAL(ims.getLimit(), 10000);
647
648 T ims2(4);
649
650 BOOST_CHECK_EQUAL(ims2.getLimit(), 4);
651}
652
653BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndDouble, T, InMemoryStoragesLimited)
654{
655 T ims(40);
656
657 for (int i = 0; i < 11; i++) {
658 std::ostringstream convert;
659 convert << i;
660 Name name("/" + convert.str());
661 shared_ptr<Data> data = makeData(name);
662 data->setFreshnessPeriod(time::milliseconds(5000));
663 signData(data);
664 ims.insert(*data);
665 }
666
667 BOOST_CHECK_EQUAL(ims.size(), 11);
668
669 BOOST_CHECK_EQUAL(ims.getCapacity(), 20);
670}
671
672BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEvict, T, InMemoryStoragesLimited)
673{
674 T ims(2);
675
676 Name name("/insert/1");
677 shared_ptr<Data> data = makeData(name);
678 ims.insert(*data);
679
680 Name name2("/insert/2");
681 shared_ptr<Data> data2 = makeData(name2);
682 ims.insert(*data2);
683
684 Name name3("/insert/3");
685 shared_ptr<Data> data3 = makeData(name3);
686 ims.insert(*data3);
687
688 BOOST_CHECK_EQUAL(ims.size(), 2);
689
690 shared_ptr<Interest> interest = makeInterest(name);
691 shared_ptr<const Data> found = ims.find(*interest);
Junxiao Shi85d90832016-08-04 03:19:46 +0000692 BOOST_CHECK(found == nullptr);
Jiewen Tan99135962014-09-20 02:18:53 -0700693}
694
Junxiao Shic542f632017-07-18 14:20:32 +0000695// Find function is implemented at the base case, so it's sufficient to test for one derived class.
Alexander Afanasyev4c9a3d52017-01-03 17:45:19 -0800696class FindFixture : public tests::UnitTestTimeFixture
Jiewen Tan99135962014-09-20 02:18:53 -0700697{
698protected:
Yingdi Yu404eafd2016-03-06 14:54:25 -0800699 FindFixture()
700 : m_ims(io)
701 {
702 }
703
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800704 Name
Yingdi Yu404eafd2016-03-06 14:54:25 -0800705 insert(uint32_t id, const Name& name,
706 const time::milliseconds& freshWindow = InMemoryStorage::INFINITE_WINDOW)
Jiewen Tan99135962014-09-20 02:18:53 -0700707 {
708 shared_ptr<Data> data = makeData(name);
709 data->setFreshnessPeriod(time::milliseconds(99999));
710 data->setContent(reinterpret_cast<const uint8_t*>(&id), sizeof(id));
711 signData(data);
712
Yingdi Yu404eafd2016-03-06 14:54:25 -0800713 m_ims.insert(*data, freshWindow);
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800714
715 return data->getFullName();
Jiewen Tan99135962014-09-20 02:18:53 -0700716 }
717
718 Interest&
719 startInterest(const Name& name)
720 {
721 m_interest = makeInterest(name);
722 return *m_interest;
723 }
724
725 uint32_t
726 find()
727 {
728 shared_ptr<const Data> found = m_ims.find(*m_interest);
729 if (found == 0) {
730 return 0;
731 }
732 const Block& content = found->getContent();
733 if (content.value_size() != sizeof(uint32_t)) {
734 return 0;
735 }
736 return *reinterpret_cast<const uint32_t*>(content.value());
737 }
738
739protected:
740 InMemoryStoragePersistent m_ims;
741 shared_ptr<Interest> m_interest;
742};
743
744BOOST_FIXTURE_TEST_SUITE(Find, FindFixture)
745
746BOOST_AUTO_TEST_CASE(EmptyDataName)
747{
748 insert(1, "ndn:/");
749
750 startInterest("ndn:/");
751 BOOST_CHECK_EQUAL(find(), 1);
752}
753
754BOOST_AUTO_TEST_CASE(EmptyInterestName)
755{
756 insert(1, "ndn:/A");
757
758 startInterest("ndn:/");
759 BOOST_CHECK_EQUAL(find(), 1);
760}
761
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800762BOOST_AUTO_TEST_CASE(ExactName)
763{
764 insert(1, "ndn:/");
765 insert(2, "ndn:/A");
766 insert(3, "ndn:/A/B");
767 insert(4, "ndn:/A/C");
768 insert(5, "ndn:/D");
769
770 startInterest("ndn:/A");
771 BOOST_CHECK_EQUAL(find(), 2);
772}
773
774BOOST_AUTO_TEST_CASE(FullName)
775{
776 Name n1 = insert(1, "ndn:/A");
777 Name n2 = insert(2, "ndn:/A");
778
779 startInterest(n1);
780 BOOST_CHECK_EQUAL(find(), 1);
781
782 startInterest(n2);
783 BOOST_CHECK_EQUAL(find(), 2);
784}
785
Jiewen Tan99135962014-09-20 02:18:53 -0700786BOOST_AUTO_TEST_CASE(Leftmost)
787{
788 insert(1, "ndn:/A");
789 insert(2, "ndn:/B/p/1");
790 insert(3, "ndn:/B/p/2");
791 insert(4, "ndn:/B/q/1");
792 insert(5, "ndn:/B/q/2");
793 insert(6, "ndn:/C");
794
795 startInterest("ndn:/B");
796 BOOST_CHECK_EQUAL(find(), 2);
797}
798
799BOOST_AUTO_TEST_CASE(Rightmost)
800{
801 insert(1, "ndn:/A");
802 insert(2, "ndn:/B/p/1");
803 insert(3, "ndn:/B/p/2");
804 insert(4, "ndn:/B/q/1");
805 insert(5, "ndn:/B/q/2");
806 insert(6, "ndn:/C");
807
808 startInterest("ndn:/B")
809 .setChildSelector(1);
810 BOOST_CHECK_EQUAL(find(), 4);
811}
812
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800813BOOST_AUTO_TEST_CASE(MinSuffixComponents)
Jiewen Tan99135962014-09-20 02:18:53 -0700814{
815 insert(1, "ndn:/");
816 insert(2, "ndn:/A");
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800817 insert(3, "ndn:/B/1");
818 insert(4, "ndn:/C/1/2");
819 insert(5, "ndn:/D/1/2/3");
820 insert(6, "ndn:/E/1/2/3/4");
Jiewen Tan99135962014-09-20 02:18:53 -0700821
822 startInterest("ndn:/")
Jiewen Tan99135962014-09-20 02:18:53 -0700823 .setMinSuffixComponents(0);
Jiewen Tan99135962014-09-20 02:18:53 -0700824 BOOST_CHECK_EQUAL(find(), 1);
825
826 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800827 .setMinSuffixComponents(1);
828 BOOST_CHECK_EQUAL(find(), 1);
829
830 startInterest("ndn:/")
831 .setMinSuffixComponents(2);
832 BOOST_CHECK_EQUAL(find(), 2);
833
834 startInterest("ndn:/")
835 .setMinSuffixComponents(3);
836 BOOST_CHECK_EQUAL(find(), 3);
837
838 startInterest("ndn:/")
839 .setMinSuffixComponents(4);
840 BOOST_CHECK_EQUAL(find(), 4);
841
842 startInterest("ndn:/")
843 .setMinSuffixComponents(5);
844 BOOST_CHECK_EQUAL(find(), 5);
845
846 startInterest("ndn:/")
847 .setMinSuffixComponents(6);
848 BOOST_CHECK_EQUAL(find(), 6);
849
850 startInterest("ndn:/")
Jiewen Tan99135962014-09-20 02:18:53 -0700851 .setMinSuffixComponents(7);
852 BOOST_CHECK_EQUAL(find(), 0);
853}
854
855BOOST_AUTO_TEST_CASE(MaxSuffixComponents)
856{
857 insert(1, "ndn:/");
858 insert(2, "ndn:/A");
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800859 insert(3, "ndn:/B/2");
860 insert(4, "ndn:/C/2/3");
861 insert(5, "ndn:/D/2/3/4");
862 insert(6, "ndn:/E/2/3/4/5");
Jiewen Tan99135962014-09-20 02:18:53 -0700863
864 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800865 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700866 .setMaxSuffixComponents(0);
867 BOOST_CHECK_EQUAL(find(), 0);
868
869 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800870 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700871 .setMaxSuffixComponents(1);
872 BOOST_CHECK_EQUAL(find(), 1);
873
874 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800875 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700876 .setMaxSuffixComponents(2);
877 BOOST_CHECK_EQUAL(find(), 2);
878
879 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800880 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700881 .setMaxSuffixComponents(3);
882 BOOST_CHECK_EQUAL(find(), 3);
883
884 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800885 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700886 .setMaxSuffixComponents(4);
887 BOOST_CHECK_EQUAL(find(), 4);
888
889 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800890 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700891 .setMaxSuffixComponents(5);
892 BOOST_CHECK_EQUAL(find(), 5);
893
894 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800895 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700896 .setMaxSuffixComponents(6);
897 BOOST_CHECK_EQUAL(find(), 6);
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800898
899 startInterest("ndn:/")
900 .setChildSelector(1)
901 .setMaxSuffixComponents(7);
902 BOOST_CHECK_EQUAL(find(), 6);
Jiewen Tan99135962014-09-20 02:18:53 -0700903}
904
905BOOST_AUTO_TEST_CASE(DigestOrder)
906{
907 insert(1, "ndn:/A");
908 insert(2, "ndn:/A");
909 // We don't know which comes first, but there must be some order
910
911 startInterest("ndn:/A")
912 .setChildSelector(0);
913 uint32_t leftmost = find();
914
915 startInterest("ndn:/A")
916 .setChildSelector(1);
917 uint32_t rightmost = find();
918
919 BOOST_CHECK_NE(leftmost, rightmost);
920}
921
922BOOST_AUTO_TEST_CASE(DigestExclude)
923{
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800924 insert(1, "ndn:/A");
925 Name n2 = insert(2, "ndn:/A");
926 insert(3, "ndn:/A/B");
927
Junxiao Shic542f632017-07-18 14:20:32 +0000928 uint8_t digest00[util::Sha256::DIGEST_SIZE];
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800929 std::fill_n(digest00, sizeof(digest00), 0x00);
Junxiao Shic542f632017-07-18 14:20:32 +0000930 uint8_t digestFF[util::Sha256::DIGEST_SIZE];
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800931 std::fill_n(digestFF, sizeof(digestFF), 0xFF);
932
933 Exclude excludeDigest;
934 excludeDigest.excludeRange(
935 name::Component::fromImplicitSha256Digest(digest00, sizeof(digest00)),
936 name::Component::fromImplicitSha256Digest(digestFF, sizeof(digestFF)));
Jiewen Tan99135962014-09-20 02:18:53 -0700937
938 startInterest("ndn:/A")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800939 .setChildSelector(0)
940 .setExclude(excludeDigest);
941 BOOST_CHECK_EQUAL(find(), 3);
Jiewen Tan99135962014-09-20 02:18:53 -0700942
943 startInterest("ndn:/A")
944 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800945 .setExclude(excludeDigest);
Jiewen Tan99135962014-09-20 02:18:53 -0700946 BOOST_CHECK_EQUAL(find(), 3);
947
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800948 Exclude excludeGeneric;
949 excludeGeneric.excludeAfter(name::Component(static_cast<uint8_t*>(nullptr), 0));
Jiewen Tan99135962014-09-20 02:18:53 -0700950
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800951 startInterest("ndn:/A")
952 .setChildSelector(0)
953 .setExclude(excludeGeneric);
954 int found1 = find();
955 BOOST_CHECK(found1 == 1 || found1 == 2);
956
957 startInterest("ndn:/A")
Jiewen Tan99135962014-09-20 02:18:53 -0700958 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800959 .setExclude(excludeGeneric);
960 int found2 = find();
961 BOOST_CHECK(found2 == 1 || found2 == 2);
962
963 Exclude exclude2 = excludeGeneric;
964 exclude2.excludeOne(n2.get(-1));
965
966 startInterest("ndn:/A")
967 .setChildSelector(0)
968 .setExclude(exclude2);
Jiewen Tan99135962014-09-20 02:18:53 -0700969 BOOST_CHECK_EQUAL(find(), 1);
970
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800971 startInterest("ndn:/A")
Jiewen Tan99135962014-09-20 02:18:53 -0700972 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800973 .setExclude(exclude2);
Jiewen Tan99135962014-09-20 02:18:53 -0700974 BOOST_CHECK_EQUAL(find(), 1);
Jiewen Tan99135962014-09-20 02:18:53 -0700975}
976
Yingdi Yu404eafd2016-03-06 14:54:25 -0800977BOOST_AUTO_TEST_CASE(MustBeFresh)
978{
979 Name data1Name = insert(1, "ndn:/A/1", time::milliseconds(500));
980 insert(2, "ndn:/A/2", time::milliseconds(2500));
981 insert(3, "ndn:/A/3", time::milliseconds(3500));
982 insert(4, "ndn:/A/4", time::milliseconds(1500));
983
984 // @0s, all Data are fresh
985 startInterest("ndn:/A/1")
986 .setMustBeFresh(true);
987 BOOST_CHECK_EQUAL(find(), 1);
988
989 startInterest("ndn:/A/1")
990 .setMustBeFresh(false);
991 BOOST_CHECK_EQUAL(find(), 1);
992
993 startInterest("ndn:/A")
994 .setMustBeFresh(true)
995 .setChildSelector(0);
996 BOOST_CHECK_EQUAL(find(), 1);
997
998 startInterest("ndn:/A")
999 .setMustBeFresh(true)
1000 .setChildSelector(1);
1001 BOOST_CHECK_EQUAL(find(), 4);
1002
1003 advanceClocks(time::milliseconds(1000));
1004 // @1s, /A/1 is stale
1005 startInterest("ndn:/A/1")
1006 .setMustBeFresh(true);
1007 BOOST_CHECK_EQUAL(find(), 0);
1008 startInterest("ndn:/A/1")
1009 .setMustBeFresh(false);
1010 BOOST_CHECK_EQUAL(find(), 1);
1011
1012 // MustBeFresh is ignored when full Name is specified
1013 startInterest(data1Name)
1014 .setMustBeFresh(true);
1015 BOOST_CHECK_EQUAL(find(), 1);
1016
1017 startInterest("ndn:/A")
1018 .setMustBeFresh(true)
1019 .setChildSelector(0);
1020 BOOST_CHECK_EQUAL(find(), 2);
1021 startInterest("ndn:/A")
1022 .setMustBeFresh(false)
1023 .setChildSelector(0);
1024 BOOST_CHECK_EQUAL(find(), 1);
1025
1026 advanceClocks(time::milliseconds(1000));
1027 // @2s, /A/1 and /A/4 are stale
1028 startInterest("ndn:/A")
1029 .setMustBeFresh(true)
1030 .setChildSelector(1);
1031 BOOST_CHECK_EQUAL(find(), 3);
1032 startInterest("ndn:/A")
1033 .setMustBeFresh(false)
1034 .setChildSelector(1);
1035 BOOST_CHECK_EQUAL(find(), 4);
1036
1037 advanceClocks(time::milliseconds(2000));
1038 // @4s, all Data are stale
1039 startInterest("ndn:/A")
1040 .setMustBeFresh(true)
1041 .setChildSelector(0);
1042 BOOST_CHECK_EQUAL(find(), 0);
1043 startInterest("ndn:/A")
1044 .setMustBeFresh(true)
1045 .setChildSelector(1);
1046 BOOST_CHECK_EQUAL(find(), 0);
1047}
1048
Alexander Afanasyev3ccc6f72014-10-12 12:19:09 -07001049BOOST_AUTO_TEST_SUITE_END() // Find
Junxiao Shi85d90832016-08-04 03:19:46 +00001050BOOST_AUTO_TEST_SUITE_END() // TestInMemoryStorage
Junxiao Shic542f632017-07-18 14:20:32 +00001051BOOST_AUTO_TEST_SUITE_END() // Ims
Jiewen Tan99135962014-09-20 02:18:53 -07001052
Junxiao Shi85d90832016-08-04 03:19:46 +00001053} // namespace tests
Jiewen Tan99135962014-09-20 02:18:53 -07001054} // namespace ndn