blob: d40f15df6fdf33ff170c8a3aa6be085af49010db [file] [log] [blame]
Junxiao Shic1e12362014-01-24 20:03:26 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/**
Junxiao Shiee5a4442014-07-27 17:13:43 -07003 * Copyright (c) 2014, Regents of the University of California,
4 * Arizona Board of Regents,
5 * Colorado State University,
6 * University Pierre & Marie Curie, Sorbonne University,
7 * Washington University in St. Louis,
8 * Beijing Institute of Technology,
9 * The University of Memphis
Alexander Afanasyev9bcbc7c2014-04-06 19:37:37 -070010 *
11 * This file is part of NFD (Named Data Networking Forwarding Daemon).
12 * See AUTHORS.md for complete list of NFD authors and contributors.
13 *
14 * NFD is free software: you can redistribute it and/or modify it under the terms
15 * of the GNU General Public License as published by the Free Software Foundation,
16 * either version 3 of the License, or (at your option) any later version.
17 *
18 * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
19 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
20 * PURPOSE. See the GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License along with
23 * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
Junxiao Shiee5a4442014-07-27 17:13:43 -070024 */
Junxiao Shic1e12362014-01-24 20:03:26 -070025
26#include "table/fib.hpp"
Alexander Afanasyev613e2a92014-04-15 13:36:58 -070027#include "tests/daemon/face/dummy-face.hpp"
Junxiao Shic1e12362014-01-24 20:03:26 -070028
Junxiao Shid9ee45c2014-02-27 15:38:11 -070029#include "tests/test-common.hpp"
Junxiao Shic1e12362014-01-24 20:03:26 -070030
Alexander Afanasyev18bbf812014-01-29 01:40:23 -080031namespace nfd {
Junxiao Shid9ee45c2014-02-27 15:38:11 -070032namespace tests {
Junxiao Shic1e12362014-01-24 20:03:26 -070033
Junxiao Shid9ee45c2014-02-27 15:38:11 -070034BOOST_FIXTURE_TEST_SUITE(TableFib, BaseFixture)
Junxiao Shic1e12362014-01-24 20:03:26 -070035
36BOOST_AUTO_TEST_CASE(Entry)
37{
38 Name prefix("ndn:/pxWhfFza");
Junxiao Shi8c8d2182014-01-30 22:33:00 -070039 shared_ptr<Face> face1 = make_shared<DummyFace>();
40 shared_ptr<Face> face2 = make_shared<DummyFace>();
Junxiao Shiefceadc2014-03-09 18:52:57 -070041
Junxiao Shic1e12362014-01-24 20:03:26 -070042 fib::Entry entry(prefix);
Junxiao Shiefceadc2014-03-09 18:52:57 -070043 BOOST_CHECK_EQUAL(entry.getPrefix(), prefix);
44
Junxiao Shic1e12362014-01-24 20:03:26 -070045 const fib::NextHopList& nexthops1 = entry.getNextHops();
46 // []
47 BOOST_CHECK_EQUAL(nexthops1.size(), 0);
Junxiao Shiefceadc2014-03-09 18:52:57 -070048
Junxiao Shic1e12362014-01-24 20:03:26 -070049 entry.addNextHop(face1, 20);
50 const fib::NextHopList& nexthops2 = entry.getNextHops();
51 // [(face1,20)]
52 BOOST_CHECK_EQUAL(nexthops2.size(), 1);
53 BOOST_CHECK_EQUAL(nexthops2.begin()->getFace(), face1);
54 BOOST_CHECK_EQUAL(nexthops2.begin()->getCost(), 20);
Junxiao Shiefceadc2014-03-09 18:52:57 -070055
Junxiao Shic1e12362014-01-24 20:03:26 -070056 entry.addNextHop(face1, 30);
57 const fib::NextHopList& nexthops3 = entry.getNextHops();
58 // [(face1,30)]
59 BOOST_CHECK_EQUAL(nexthops3.size(), 1);
60 BOOST_CHECK_EQUAL(nexthops3.begin()->getFace(), face1);
61 BOOST_CHECK_EQUAL(nexthops3.begin()->getCost(), 30);
62
63 entry.addNextHop(face2, 40);
64 const fib::NextHopList& nexthops4 = entry.getNextHops();
65 // [(face1,30), (face2,40)]
66 BOOST_CHECK_EQUAL(nexthops4.size(), 2);
67 int i = -1;
68 for (fib::NextHopList::const_iterator it = nexthops4.begin();
69 it != nexthops4.end(); ++it) {
70 ++i;
71 switch (i) {
72 case 0 :
73 BOOST_CHECK_EQUAL(it->getFace(), face1);
74 BOOST_CHECK_EQUAL(it->getCost(), 30);
75 break;
76 case 1 :
77 BOOST_CHECK_EQUAL(it->getFace(), face2);
78 BOOST_CHECK_EQUAL(it->getCost(), 40);
79 break;
80 }
81 }
82
83 entry.addNextHop(face2, 10);
84 const fib::NextHopList& nexthops5 = entry.getNextHops();
85 // [(face2,10), (face1,30)]
86 BOOST_CHECK_EQUAL(nexthops5.size(), 2);
87 i = -1;
88 for (fib::NextHopList::const_iterator it = nexthops5.begin();
89 it != nexthops5.end(); ++it) {
90 ++i;
91 switch (i) {
92 case 0 :
93 BOOST_CHECK_EQUAL(it->getFace(), face2);
94 BOOST_CHECK_EQUAL(it->getCost(), 10);
95 break;
96 case 1 :
97 BOOST_CHECK_EQUAL(it->getFace(), face1);
98 BOOST_CHECK_EQUAL(it->getCost(), 30);
99 break;
100 }
101 }
Junxiao Shiefceadc2014-03-09 18:52:57 -0700102
Junxiao Shic1e12362014-01-24 20:03:26 -0700103 entry.removeNextHop(face1);
104 const fib::NextHopList& nexthops6 = entry.getNextHops();
105 // [(face2,10)]
106 BOOST_CHECK_EQUAL(nexthops6.size(), 1);
107 BOOST_CHECK_EQUAL(nexthops6.begin()->getFace(), face2);
108 BOOST_CHECK_EQUAL(nexthops6.begin()->getCost(), 10);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700109
Junxiao Shic1e12362014-01-24 20:03:26 -0700110 entry.removeNextHop(face1);
111 const fib::NextHopList& nexthops7 = entry.getNextHops();
112 // [(face2,10)]
113 BOOST_CHECK_EQUAL(nexthops7.size(), 1);
114 BOOST_CHECK_EQUAL(nexthops7.begin()->getFace(), face2);
115 BOOST_CHECK_EQUAL(nexthops7.begin()->getCost(), 10);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700116
Junxiao Shic1e12362014-01-24 20:03:26 -0700117 entry.removeNextHop(face2);
118 const fib::NextHopList& nexthops8 = entry.getNextHops();
119 // []
120 BOOST_CHECK_EQUAL(nexthops8.size(), 0);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700121
Junxiao Shic1e12362014-01-24 20:03:26 -0700122 entry.removeNextHop(face2);
123 const fib::NextHopList& nexthops9 = entry.getNextHops();
124 // []
125 BOOST_CHECK_EQUAL(nexthops9.size(), 0);
126}
127
128BOOST_AUTO_TEST_CASE(Insert_LongestPrefixMatch)
129{
130 Name nameEmpty;
131 Name nameA ("ndn:/A");
132 Name nameAB ("ndn:/A/B");
133 Name nameABC ("ndn:/A/B/C");
134 Name nameABCD("ndn:/A/B/C/D");
135 Name nameE ("ndn:/E");
Junxiao Shiefceadc2014-03-09 18:52:57 -0700136
Junxiao Shic1e12362014-01-24 20:03:26 -0700137 std::pair<shared_ptr<fib::Entry>, bool> insertRes;
138 shared_ptr<fib::Entry> entry;
139
Haowei Yuanf52dac72014-03-24 23:35:03 -0500140 NameTree nameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800141 Fib fib(nameTree);
Junxiao Shi40631842014-03-01 13:52:37 -0700142 // []
Junxiao Shiefceadc2014-03-09 18:52:57 -0700143 BOOST_CHECK_EQUAL(fib.size(), 0);
Junxiao Shi40631842014-03-01 13:52:37 -0700144
145 entry = fib.findLongestPrefixMatch(nameA);
146 BOOST_REQUIRE(static_cast<bool>(entry)); // the empty entry
Junxiao Shiefceadc2014-03-09 18:52:57 -0700147
Junxiao Shi40631842014-03-01 13:52:37 -0700148 insertRes = fib.insert(nameEmpty);
149 BOOST_CHECK_EQUAL(insertRes.second, true);
150 BOOST_CHECK_EQUAL(insertRes.first->getPrefix(), nameEmpty);
Junxiao Shic1e12362014-01-24 20:03:26 -0700151 // ['/']
Junxiao Shiefceadc2014-03-09 18:52:57 -0700152 BOOST_CHECK_EQUAL(fib.size(), 1);
153
Junxiao Shic1e12362014-01-24 20:03:26 -0700154 entry = fib.findLongestPrefixMatch(nameA);
Junxiao Shi40631842014-03-01 13:52:37 -0700155 BOOST_REQUIRE(static_cast<bool>(entry));
156 BOOST_CHECK_EQUAL(entry->getPrefix(), nameEmpty);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700157
Junxiao Shic1e12362014-01-24 20:03:26 -0700158 insertRes = fib.insert(nameA);
159 BOOST_CHECK_EQUAL(insertRes.second, true);
Junxiao Shi40631842014-03-01 13:52:37 -0700160 BOOST_CHECK_EQUAL(insertRes.first->getPrefix(), nameA);
Junxiao Shic1e12362014-01-24 20:03:26 -0700161 // ['/', '/A']
Junxiao Shiefceadc2014-03-09 18:52:57 -0700162 BOOST_CHECK_EQUAL(fib.size(), 2);
163
Junxiao Shic1e12362014-01-24 20:03:26 -0700164 insertRes = fib.insert(nameA);
165 BOOST_CHECK_EQUAL(insertRes.second, false);
Junxiao Shi40631842014-03-01 13:52:37 -0700166 BOOST_CHECK_EQUAL(insertRes.first->getPrefix(), nameA);
Junxiao Shic1e12362014-01-24 20:03:26 -0700167 // ['/', '/A']
Junxiao Shiefceadc2014-03-09 18:52:57 -0700168 BOOST_CHECK_EQUAL(fib.size(), 2);
Junxiao Shic1e12362014-01-24 20:03:26 -0700169
170 entry = fib.findLongestPrefixMatch(nameA);
Junxiao Shi40631842014-03-01 13:52:37 -0700171 BOOST_REQUIRE(static_cast<bool>(entry));
172 BOOST_CHECK_EQUAL(entry->getPrefix(), nameA);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700173
Junxiao Shic1e12362014-01-24 20:03:26 -0700174 entry = fib.findLongestPrefixMatch(nameABCD);
Junxiao Shi40631842014-03-01 13:52:37 -0700175 BOOST_REQUIRE(static_cast<bool>(entry));
176 BOOST_CHECK_EQUAL(entry->getPrefix(), nameA);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700177
Junxiao Shic1e12362014-01-24 20:03:26 -0700178 insertRes = fib.insert(nameABC);
179 BOOST_CHECK_EQUAL(insertRes.second, true);
Junxiao Shi40631842014-03-01 13:52:37 -0700180 BOOST_CHECK_EQUAL(insertRes.first->getPrefix(), nameABC);
Junxiao Shic1e12362014-01-24 20:03:26 -0700181 // ['/', '/A', '/A/B/C']
Junxiao Shiefceadc2014-03-09 18:52:57 -0700182 BOOST_CHECK_EQUAL(fib.size(), 3);
Junxiao Shic1e12362014-01-24 20:03:26 -0700183
184 entry = fib.findLongestPrefixMatch(nameA);
Junxiao Shi40631842014-03-01 13:52:37 -0700185 BOOST_REQUIRE(static_cast<bool>(entry));
186 BOOST_CHECK_EQUAL(entry->getPrefix(), nameA);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700187
Junxiao Shic1e12362014-01-24 20:03:26 -0700188 entry = fib.findLongestPrefixMatch(nameAB);
Junxiao Shi40631842014-03-01 13:52:37 -0700189 BOOST_REQUIRE(static_cast<bool>(entry));
190 BOOST_CHECK_EQUAL(entry->getPrefix(), nameA);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700191
Junxiao Shic1e12362014-01-24 20:03:26 -0700192 entry = fib.findLongestPrefixMatch(nameABCD);
Junxiao Shi40631842014-03-01 13:52:37 -0700193 BOOST_REQUIRE(static_cast<bool>(entry));
194 BOOST_CHECK_EQUAL(entry->getPrefix(), nameABC);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700195
Junxiao Shic1e12362014-01-24 20:03:26 -0700196 entry = fib.findLongestPrefixMatch(nameE);
Junxiao Shi40631842014-03-01 13:52:37 -0700197 BOOST_REQUIRE(static_cast<bool>(entry));
198 BOOST_CHECK_EQUAL(entry->getPrefix(), nameEmpty);
Junxiao Shic1e12362014-01-24 20:03:26 -0700199}
200
201BOOST_AUTO_TEST_CASE(RemoveNextHopFromAllEntries)
202{
Junxiao Shi8c8d2182014-01-30 22:33:00 -0700203 shared_ptr<Face> face1 = make_shared<DummyFace>();
204 shared_ptr<Face> face2 = make_shared<DummyFace>();
Junxiao Shiefceadc2014-03-09 18:52:57 -0700205 Name nameEmpty("ndn:/");
Junxiao Shic1e12362014-01-24 20:03:26 -0700206 Name nameA("ndn:/A");
207 Name nameB("ndn:/B");
Junxiao Shiefceadc2014-03-09 18:52:57 -0700208
Junxiao Shic1e12362014-01-24 20:03:26 -0700209 std::pair<shared_ptr<fib::Entry>, bool> insertRes;
210 shared_ptr<fib::Entry> entry;
Junxiao Shiefceadc2014-03-09 18:52:57 -0700211
Haowei Yuanf52dac72014-03-24 23:35:03 -0500212 NameTree nameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800213 Fib fib(nameTree);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700214 // {}
215
Junxiao Shic1e12362014-01-24 20:03:26 -0700216 insertRes = fib.insert(nameA);
217 insertRes.first->addNextHop(face1, 0);
218 insertRes.first->addNextHop(face2, 0);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700219 // {'/A':[1,2]}
Junxiao Shic1e12362014-01-24 20:03:26 -0700220
221 insertRes = fib.insert(nameB);
222 insertRes.first->addNextHop(face1, 0);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700223 // {'/A':[1,2], '/B':[1]}
224 BOOST_CHECK_EQUAL(fib.size(), 2);
225
Junxiao Shic1e12362014-01-24 20:03:26 -0700226 fib.removeNextHopFromAllEntries(face1);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700227 // {'/A':[2]}
228 BOOST_CHECK_EQUAL(fib.size(), 1);
229
Junxiao Shic1e12362014-01-24 20:03:26 -0700230 entry = fib.findLongestPrefixMatch(nameA);
Junxiao Shi40631842014-03-01 13:52:37 -0700231 BOOST_CHECK_EQUAL(entry->getPrefix(), nameA);
Junxiao Shic1e12362014-01-24 20:03:26 -0700232 const fib::NextHopList& nexthopsA = entry->getNextHops();
233 BOOST_CHECK_EQUAL(nexthopsA.size(), 1);
234 BOOST_CHECK_EQUAL(nexthopsA.begin()->getFace(), face2);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700235
Junxiao Shic1e12362014-01-24 20:03:26 -0700236 entry = fib.findLongestPrefixMatch(nameB);
Junxiao Shiefceadc2014-03-09 18:52:57 -0700237 BOOST_CHECK_EQUAL(entry->getPrefix(), nameEmpty);
Junxiao Shic1e12362014-01-24 20:03:26 -0700238}
239
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700240void
241validateFindExactMatch(const Fib& fib, const Name& target)
242{
243 shared_ptr<fib::Entry> entry = fib.findExactMatch(target);
244 if (static_cast<bool>(entry))
245 {
246 BOOST_CHECK_EQUAL(entry->getPrefix(), target);
247 }
248 else
249 {
250 BOOST_FAIL("No entry found for " << target);
251 }
252}
253
254void
255validateNoExactMatch(const Fib& fib, const Name& target)
256{
257 shared_ptr<fib::Entry> entry = fib.findExactMatch(target);
258 if (static_cast<bool>(entry))
259 {
260 BOOST_FAIL("Found unexpected entry for " << target);
261 }
262}
263
264BOOST_AUTO_TEST_CASE(FindExactMatch)
265{
Haowei Yuanf52dac72014-03-24 23:35:03 -0500266 NameTree nameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800267 Fib fib(nameTree);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700268 fib.insert("/A");
269 fib.insert("/A/B");
270 fib.insert("/A/B/C");
271
272 validateFindExactMatch(fib, "/A");
273 validateFindExactMatch(fib, "/A/B");
274 validateFindExactMatch(fib, "/A/B/C");
Junxiao Shi40631842014-03-01 13:52:37 -0700275 validateNoExactMatch(fib, "/");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700276
277 validateNoExactMatch(fib, "/does/not/exist");
278
Haowei Yuanf52dac72014-03-24 23:35:03 -0500279 NameTree gapNameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800280 Fib gapFib(nameTree);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700281 fib.insert("/X");
282 fib.insert("/X/Y/Z");
283
284 validateNoExactMatch(gapFib, "/X/Y");
285
Haowei Yuanf52dac72014-03-24 23:35:03 -0500286 NameTree emptyNameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800287 Fib emptyFib(emptyNameTree);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700288 validateNoExactMatch(emptyFib, "/nothing/here");
289}
290
291void
Junxiao Shiee5a4442014-07-27 17:13:43 -0700292validateErase(Fib& fib, const Name& target)
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700293{
HangZhangad4afd12014-03-01 11:03:08 +0800294 fib.erase(target);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700295
296 shared_ptr<fib::Entry> entry = fib.findExactMatch(target);
297 if (static_cast<bool>(entry))
298 {
299 BOOST_FAIL("Found \"removed\" entry for " << target);
300 }
301}
302
Junxiao Shiee5a4442014-07-27 17:13:43 -0700303BOOST_AUTO_TEST_CASE(Erase)
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700304{
Haowei Yuanf52dac72014-03-24 23:35:03 -0500305 NameTree emptyNameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800306 Fib emptyFib(emptyNameTree);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700307
HangZhangad4afd12014-03-01 11:03:08 +0800308 emptyFib.erase("/does/not/exist"); // crash test
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700309
Junxiao Shiee5a4442014-07-27 17:13:43 -0700310 validateErase(emptyFib, "/");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700311
HangZhangad4afd12014-03-01 11:03:08 +0800312 emptyFib.erase("/still/does/not/exist"); // crash test
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700313
Haowei Yuanf52dac72014-03-24 23:35:03 -0500314 NameTree nameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800315 Fib fib(nameTree);
Junxiao Shi40631842014-03-01 13:52:37 -0700316 fib.insert("/");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700317 fib.insert("/A");
318 fib.insert("/A/B");
319 fib.insert("/A/B/C");
320
321 // check if we remove the right thing and leave
322 // everything else alone
323
Junxiao Shiee5a4442014-07-27 17:13:43 -0700324 validateErase(fib, "/A/B");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700325 validateFindExactMatch(fib, "/A");
326 validateFindExactMatch(fib, "/A/B/C");
327 validateFindExactMatch(fib, "/");
328
Junxiao Shiee5a4442014-07-27 17:13:43 -0700329 validateErase(fib, "/A/B/C");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700330 validateFindExactMatch(fib, "/A");
331 validateFindExactMatch(fib, "/");
332
Junxiao Shiee5a4442014-07-27 17:13:43 -0700333 validateErase(fib, "/A");
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700334 validateFindExactMatch(fib, "/");
335
Junxiao Shiee5a4442014-07-27 17:13:43 -0700336 validateErase(fib, "/");
Junxiao Shi40631842014-03-01 13:52:37 -0700337 validateNoExactMatch(fib, "/");
338
Haowei Yuanf52dac72014-03-24 23:35:03 -0500339 NameTree gapNameTree;
HangZhangad4afd12014-03-01 11:03:08 +0800340 Fib gapFib(gapNameTree);
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700341 gapFib.insert("/X");
342 gapFib.insert("/X/Y/Z");
343
HangZhangad4afd12014-03-01 11:03:08 +0800344 gapFib.erase("/X/Y"); //should do nothing
Steve DiBenedettod5f87932014-02-05 15:11:39 -0700345 validateFindExactMatch(gapFib, "/X");
346 validateFindExactMatch(gapFib, "/X/Y/Z");
347}
348
Junxiao Shiee5a4442014-07-27 17:13:43 -0700349BOOST_AUTO_TEST_CASE(EraseNameTreeEntry)
350{
351 NameTree nameTree;
352 Fib fib(nameTree);
353 size_t nNameTreeEntriesBefore = nameTree.size();
354
355 fib.insert("ndn:/A/B/C");
356 fib.erase("ndn:/A/B/C");
357 BOOST_CHECK_EQUAL(nameTree.size(), nNameTreeEntriesBefore);
358}
359
HangZhang5d469422014-03-12 09:26:26 +0800360BOOST_AUTO_TEST_CASE(Iterator)
361{
Haowei Yuanf52dac72014-03-24 23:35:03 -0500362 NameTree nameTree;
HangZhang5d469422014-03-12 09:26:26 +0800363 Fib fib(nameTree);
364 Name nameA("/A");
365 Name nameAB("/A/B");
366 Name nameABC("/A/B/C");
367 Name nameRoot("/");
368
369 fib.insert(nameA);
370 fib.insert(nameAB);
371 fib.insert(nameABC);
372 fib.insert(nameRoot);
373
374 std::set<Name> expected;
375 expected.insert(nameA);
376 expected.insert(nameAB);
377 expected.insert(nameABC);
378 expected.insert(nameRoot);
379
380 for (Fib::const_iterator it = fib.begin(); it != fib.end(); it++)
381 {
382 bool isInSet = expected.find(it->getPrefix()) != expected.end();
383 BOOST_CHECK(isInSet);
384 expected.erase(it->getPrefix());
385 }
386
387 BOOST_CHECK_EQUAL(expected.size(), 0);
388}
389
Junxiao Shic1e12362014-01-24 20:03:26 -0700390BOOST_AUTO_TEST_SUITE_END()
391
Junxiao Shid9ee45c2014-02-27 15:38:11 -0700392} // namespace tests
Alexander Afanasyev18bbf812014-01-29 01:40:23 -0800393} // namespace nfd