blob: 3689c53cdb827efb02b2e3acd81e1f587a470ea5 [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 }
Junxiao Shibaab7322017-07-27 01:22:49 +0000736 uint32_t id = 0;
737 std::memcpy(&id, content.value(), sizeof(id));
738 return id;
Jiewen Tan99135962014-09-20 02:18:53 -0700739 }
740
741protected:
742 InMemoryStoragePersistent m_ims;
743 shared_ptr<Interest> m_interest;
744};
745
746BOOST_FIXTURE_TEST_SUITE(Find, FindFixture)
747
748BOOST_AUTO_TEST_CASE(EmptyDataName)
749{
750 insert(1, "ndn:/");
751
752 startInterest("ndn:/");
753 BOOST_CHECK_EQUAL(find(), 1);
754}
755
756BOOST_AUTO_TEST_CASE(EmptyInterestName)
757{
758 insert(1, "ndn:/A");
759
760 startInterest("ndn:/");
761 BOOST_CHECK_EQUAL(find(), 1);
762}
763
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800764BOOST_AUTO_TEST_CASE(ExactName)
765{
766 insert(1, "ndn:/");
767 insert(2, "ndn:/A");
768 insert(3, "ndn:/A/B");
769 insert(4, "ndn:/A/C");
770 insert(5, "ndn:/D");
771
772 startInterest("ndn:/A");
773 BOOST_CHECK_EQUAL(find(), 2);
774}
775
776BOOST_AUTO_TEST_CASE(FullName)
777{
778 Name n1 = insert(1, "ndn:/A");
779 Name n2 = insert(2, "ndn:/A");
780
781 startInterest(n1);
782 BOOST_CHECK_EQUAL(find(), 1);
783
784 startInterest(n2);
785 BOOST_CHECK_EQUAL(find(), 2);
786}
787
Jiewen Tan99135962014-09-20 02:18:53 -0700788BOOST_AUTO_TEST_CASE(Leftmost)
789{
790 insert(1, "ndn:/A");
791 insert(2, "ndn:/B/p/1");
792 insert(3, "ndn:/B/p/2");
793 insert(4, "ndn:/B/q/1");
794 insert(5, "ndn:/B/q/2");
795 insert(6, "ndn:/C");
796
797 startInterest("ndn:/B");
798 BOOST_CHECK_EQUAL(find(), 2);
799}
800
801BOOST_AUTO_TEST_CASE(Rightmost)
802{
803 insert(1, "ndn:/A");
804 insert(2, "ndn:/B/p/1");
805 insert(3, "ndn:/B/p/2");
806 insert(4, "ndn:/B/q/1");
807 insert(5, "ndn:/B/q/2");
808 insert(6, "ndn:/C");
809
810 startInterest("ndn:/B")
811 .setChildSelector(1);
812 BOOST_CHECK_EQUAL(find(), 4);
813}
814
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800815BOOST_AUTO_TEST_CASE(MinSuffixComponents)
Jiewen Tan99135962014-09-20 02:18:53 -0700816{
817 insert(1, "ndn:/");
818 insert(2, "ndn:/A");
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800819 insert(3, "ndn:/B/1");
820 insert(4, "ndn:/C/1/2");
821 insert(5, "ndn:/D/1/2/3");
822 insert(6, "ndn:/E/1/2/3/4");
Jiewen Tan99135962014-09-20 02:18:53 -0700823
824 startInterest("ndn:/")
Jiewen Tan99135962014-09-20 02:18:53 -0700825 .setMinSuffixComponents(0);
Jiewen Tan99135962014-09-20 02:18:53 -0700826 BOOST_CHECK_EQUAL(find(), 1);
827
828 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800829 .setMinSuffixComponents(1);
830 BOOST_CHECK_EQUAL(find(), 1);
831
832 startInterest("ndn:/")
833 .setMinSuffixComponents(2);
834 BOOST_CHECK_EQUAL(find(), 2);
835
836 startInterest("ndn:/")
837 .setMinSuffixComponents(3);
838 BOOST_CHECK_EQUAL(find(), 3);
839
840 startInterest("ndn:/")
841 .setMinSuffixComponents(4);
842 BOOST_CHECK_EQUAL(find(), 4);
843
844 startInterest("ndn:/")
845 .setMinSuffixComponents(5);
846 BOOST_CHECK_EQUAL(find(), 5);
847
848 startInterest("ndn:/")
849 .setMinSuffixComponents(6);
850 BOOST_CHECK_EQUAL(find(), 6);
851
852 startInterest("ndn:/")
Jiewen Tan99135962014-09-20 02:18:53 -0700853 .setMinSuffixComponents(7);
854 BOOST_CHECK_EQUAL(find(), 0);
855}
856
857BOOST_AUTO_TEST_CASE(MaxSuffixComponents)
858{
859 insert(1, "ndn:/");
860 insert(2, "ndn:/A");
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800861 insert(3, "ndn:/B/2");
862 insert(4, "ndn:/C/2/3");
863 insert(5, "ndn:/D/2/3/4");
864 insert(6, "ndn:/E/2/3/4/5");
Jiewen Tan99135962014-09-20 02:18:53 -0700865
866 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800867 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700868 .setMaxSuffixComponents(0);
869 BOOST_CHECK_EQUAL(find(), 0);
870
871 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800872 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700873 .setMaxSuffixComponents(1);
874 BOOST_CHECK_EQUAL(find(), 1);
875
876 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800877 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700878 .setMaxSuffixComponents(2);
879 BOOST_CHECK_EQUAL(find(), 2);
880
881 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800882 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700883 .setMaxSuffixComponents(3);
884 BOOST_CHECK_EQUAL(find(), 3);
885
886 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800887 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700888 .setMaxSuffixComponents(4);
889 BOOST_CHECK_EQUAL(find(), 4);
890
891 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800892 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700893 .setMaxSuffixComponents(5);
894 BOOST_CHECK_EQUAL(find(), 5);
895
896 startInterest("ndn:/")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800897 .setChildSelector(1)
Jiewen Tan99135962014-09-20 02:18:53 -0700898 .setMaxSuffixComponents(6);
899 BOOST_CHECK_EQUAL(find(), 6);
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800900
901 startInterest("ndn:/")
902 .setChildSelector(1)
903 .setMaxSuffixComponents(7);
904 BOOST_CHECK_EQUAL(find(), 6);
Jiewen Tan99135962014-09-20 02:18:53 -0700905}
906
907BOOST_AUTO_TEST_CASE(DigestOrder)
908{
909 insert(1, "ndn:/A");
910 insert(2, "ndn:/A");
911 // We don't know which comes first, but there must be some order
912
913 startInterest("ndn:/A")
914 .setChildSelector(0);
915 uint32_t leftmost = find();
916
917 startInterest("ndn:/A")
918 .setChildSelector(1);
919 uint32_t rightmost = find();
920
921 BOOST_CHECK_NE(leftmost, rightmost);
922}
923
924BOOST_AUTO_TEST_CASE(DigestExclude)
925{
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800926 insert(1, "ndn:/A");
927 Name n2 = insert(2, "ndn:/A");
928 insert(3, "ndn:/A/B");
929
Junxiao Shic542f632017-07-18 14:20:32 +0000930 uint8_t digest00[util::Sha256::DIGEST_SIZE];
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800931 std::fill_n(digest00, sizeof(digest00), 0x00);
Junxiao Shic542f632017-07-18 14:20:32 +0000932 uint8_t digestFF[util::Sha256::DIGEST_SIZE];
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800933 std::fill_n(digestFF, sizeof(digestFF), 0xFF);
934
935 Exclude excludeDigest;
936 excludeDigest.excludeRange(
937 name::Component::fromImplicitSha256Digest(digest00, sizeof(digest00)),
938 name::Component::fromImplicitSha256Digest(digestFF, sizeof(digestFF)));
Jiewen Tan99135962014-09-20 02:18:53 -0700939
940 startInterest("ndn:/A")
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800941 .setChildSelector(0)
942 .setExclude(excludeDigest);
943 BOOST_CHECK_EQUAL(find(), 3);
Jiewen Tan99135962014-09-20 02:18:53 -0700944
945 startInterest("ndn:/A")
946 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800947 .setExclude(excludeDigest);
Jiewen Tan99135962014-09-20 02:18:53 -0700948 BOOST_CHECK_EQUAL(find(), 3);
949
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800950 Exclude excludeGeneric;
951 excludeGeneric.excludeAfter(name::Component(static_cast<uint8_t*>(nullptr), 0));
Jiewen Tan99135962014-09-20 02:18:53 -0700952
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800953 startInterest("ndn:/A")
954 .setChildSelector(0)
955 .setExclude(excludeGeneric);
956 int found1 = find();
957 BOOST_CHECK(found1 == 1 || found1 == 2);
958
959 startInterest("ndn:/A")
Jiewen Tan99135962014-09-20 02:18:53 -0700960 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800961 .setExclude(excludeGeneric);
962 int found2 = find();
963 BOOST_CHECK(found2 == 1 || found2 == 2);
964
965 Exclude exclude2 = excludeGeneric;
966 exclude2.excludeOne(n2.get(-1));
967
968 startInterest("ndn:/A")
969 .setChildSelector(0)
970 .setExclude(exclude2);
Jiewen Tan99135962014-09-20 02:18:53 -0700971 BOOST_CHECK_EQUAL(find(), 1);
972
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800973 startInterest("ndn:/A")
Jiewen Tan99135962014-09-20 02:18:53 -0700974 .setChildSelector(1)
Alexander Afanasyev8cf2f2c2015-01-31 21:33:46 -0800975 .setExclude(exclude2);
Jiewen Tan99135962014-09-20 02:18:53 -0700976 BOOST_CHECK_EQUAL(find(), 1);
Jiewen Tan99135962014-09-20 02:18:53 -0700977}
978
Yingdi Yu404eafd2016-03-06 14:54:25 -0800979BOOST_AUTO_TEST_CASE(MustBeFresh)
980{
981 Name data1Name = insert(1, "ndn:/A/1", time::milliseconds(500));
982 insert(2, "ndn:/A/2", time::milliseconds(2500));
983 insert(3, "ndn:/A/3", time::milliseconds(3500));
984 insert(4, "ndn:/A/4", time::milliseconds(1500));
985
986 // @0s, all Data are fresh
987 startInterest("ndn:/A/1")
988 .setMustBeFresh(true);
989 BOOST_CHECK_EQUAL(find(), 1);
990
991 startInterest("ndn:/A/1")
992 .setMustBeFresh(false);
993 BOOST_CHECK_EQUAL(find(), 1);
994
995 startInterest("ndn:/A")
996 .setMustBeFresh(true)
997 .setChildSelector(0);
998 BOOST_CHECK_EQUAL(find(), 1);
999
1000 startInterest("ndn:/A")
1001 .setMustBeFresh(true)
1002 .setChildSelector(1);
1003 BOOST_CHECK_EQUAL(find(), 4);
1004
1005 advanceClocks(time::milliseconds(1000));
1006 // @1s, /A/1 is stale
1007 startInterest("ndn:/A/1")
1008 .setMustBeFresh(true);
1009 BOOST_CHECK_EQUAL(find(), 0);
1010 startInterest("ndn:/A/1")
1011 .setMustBeFresh(false);
1012 BOOST_CHECK_EQUAL(find(), 1);
1013
1014 // MustBeFresh is ignored when full Name is specified
1015 startInterest(data1Name)
1016 .setMustBeFresh(true);
1017 BOOST_CHECK_EQUAL(find(), 1);
1018
1019 startInterest("ndn:/A")
1020 .setMustBeFresh(true)
1021 .setChildSelector(0);
1022 BOOST_CHECK_EQUAL(find(), 2);
1023 startInterest("ndn:/A")
1024 .setMustBeFresh(false)
1025 .setChildSelector(0);
1026 BOOST_CHECK_EQUAL(find(), 1);
1027
1028 advanceClocks(time::milliseconds(1000));
1029 // @2s, /A/1 and /A/4 are stale
1030 startInterest("ndn:/A")
1031 .setMustBeFresh(true)
1032 .setChildSelector(1);
1033 BOOST_CHECK_EQUAL(find(), 3);
1034 startInterest("ndn:/A")
1035 .setMustBeFresh(false)
1036 .setChildSelector(1);
1037 BOOST_CHECK_EQUAL(find(), 4);
1038
1039 advanceClocks(time::milliseconds(2000));
1040 // @4s, all Data are stale
1041 startInterest("ndn:/A")
1042 .setMustBeFresh(true)
1043 .setChildSelector(0);
1044 BOOST_CHECK_EQUAL(find(), 0);
1045 startInterest("ndn:/A")
1046 .setMustBeFresh(true)
1047 .setChildSelector(1);
1048 BOOST_CHECK_EQUAL(find(), 0);
1049}
1050
Alexander Afanasyev3ccc6f72014-10-12 12:19:09 -07001051BOOST_AUTO_TEST_SUITE_END() // Find
Junxiao Shi85d90832016-08-04 03:19:46 +00001052BOOST_AUTO_TEST_SUITE_END() // TestInMemoryStorage
Junxiao Shic542f632017-07-18 14:20:32 +00001053BOOST_AUTO_TEST_SUITE_END() // Ims
Jiewen Tan99135962014-09-20 02:18:53 -07001054
Junxiao Shi85d90832016-08-04 03:19:46 +00001055} // namespace tests
Jiewen Tan99135962014-09-20 02:18:53 -07001056} // namespace ndn