Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 2 | /* |
Davide Pesavento | fbea4fc | 2022-02-08 07:26:04 -0500 | [diff] [blame] | 3 | * Copyright (c) 2013-2022 Regents of the University of California. |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 4 | * |
| 5 | * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions). |
Alexander Afanasyev | dfa52c4 | 2014-04-24 21:10:11 -0700 | [diff] [blame] | 6 | * |
Alexander Afanasyev | c169a81 | 2014-05-20 20:37:29 -0400 | [diff] [blame] | 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. |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 20 | */ |
| 21 | |
Davide Pesavento | 7e78064 | 2018-11-24 15:51:34 -0500 | [diff] [blame] | 22 | #include "ndn-cxx/name.hpp" |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 23 | |
Davide Pesavento | 7e78064 | 2018-11-24 15:51:34 -0500 | [diff] [blame] | 24 | #include "tests/boost-test.hpp" |
| 25 | |
Yingdi Yu | 90e2358 | 2014-11-06 14:21:04 -0800 | [diff] [blame] | 26 | #include <unordered_map> |
Alexander Afanasyev | b1db7c6 | 2014-04-03 14:57:25 -0700 | [diff] [blame] | 27 | |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 28 | namespace ndn { |
Junxiao Shi | 6bf0adf | 2015-02-15 13:54:56 -0700 | [diff] [blame] | 29 | namespace tests { |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 30 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 31 | using Component = name::Component; |
Junxiao Shi | a39c0b5 | 2019-12-31 15:13:15 -0700 | [diff] [blame] | 32 | using UriFormat = name::UriFormat; |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 33 | |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 34 | BOOST_AUTO_TEST_SUITE(TestName) |
| 35 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 36 | // ---- encoding, decoding, and URI ---- |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 37 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 38 | BOOST_AUTO_TEST_CASE(EncodeDecode) |
Alexander Afanasyev | c234429 | 2014-03-02 00:08:00 +0000 | [diff] [blame] | 39 | { |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 40 | std::string uri = "/Emid/25042=P3/.../..../%1C%9F/" |
| 41 | "sha256digest=0415e3624a151850ac686c84f155f29808c0dd73819aa4a4c20be73a4d8a874c"; |
| 42 | Name name(uri); |
| 43 | BOOST_CHECK_EQUAL(name.size(), 6); |
| 44 | BOOST_CHECK_EQUAL(name[0], Component("Emid")); |
| 45 | BOOST_CHECK_EQUAL(name[1], Component("FD61D2025033"_block)); |
| 46 | BOOST_CHECK_EQUAL(name[2], Component("")); |
| 47 | BOOST_CHECK_EQUAL(name[3], Component(".")); |
| 48 | BOOST_CHECK_EQUAL(name[4], Component("\x1C\x9F")); |
| 49 | BOOST_CHECK(name[5].isImplicitSha256Digest()); |
Alexander Afanasyev | c234429 | 2014-03-02 00:08:00 +0000 | [diff] [blame] | 50 | |
Junxiao Shi | a39c0b5 | 2019-12-31 15:13:15 -0700 | [diff] [blame] | 51 | BOOST_CHECK_EQUAL(name.toUri(UriFormat::CANONICAL), |
| 52 | "/8=Emid/25042=P3/8=.../8=..../8=%1C%9F/" |
| 53 | "1=%04%15%E3bJ%15%18P%AChl%84%F1U%F2%98%08%C0%DDs%81%9A%A4%A4%C2%0B%E7%3AM%8A%87L"); |
| 54 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 55 | Block wire = name.wireEncode(); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 56 | BOOST_CHECK_EQUAL(wire, |
| 57 | "0737 0804456D6964 FD61D2025033 0800 08012E 08021C9F " |
| 58 | "01200415E3624A151850AC686C84F155F29808C0DD73819AA4A4C20BE73A4D8A874C"_block); |
Alexander Afanasyev | c234429 | 2014-03-02 00:08:00 +0000 | [diff] [blame] | 59 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 60 | Name decoded(wire); |
| 61 | BOOST_CHECK_EQUAL(decoded, name); |
Alexander Afanasyev | 6486d52 | 2014-10-23 14:14:11 -0700 | [diff] [blame] | 62 | } |
| 63 | |
Junxiao Shi | 9c9672e | 2018-04-18 12:55:08 +0000 | [diff] [blame] | 64 | BOOST_AUTO_TEST_CASE(ParseUri) |
Alexander Afanasyev | d7eacc7 | 2015-04-03 13:06:26 -0700 | [diff] [blame] | 65 | { |
Junxiao Shi | a39c0b5 | 2019-12-31 15:13:15 -0700 | [diff] [blame] | 66 | // canonical URI |
| 67 | BOOST_CHECK_EQUAL(Name("/8=hello/8=world").toUri(), "/hello/world"); |
| 68 | |
Junxiao Shi | 9c9672e | 2018-04-18 12:55:08 +0000 | [diff] [blame] | 69 | // URI with correct scheme |
| 70 | BOOST_CHECK_EQUAL(Name("ndn:/hello/world").toUri(), "/hello/world"); |
Alexander Afanasyev | d7eacc7 | 2015-04-03 13:06:26 -0700 | [diff] [blame] | 71 | |
Junxiao Shi | 9c9672e | 2018-04-18 12:55:08 +0000 | [diff] [blame] | 72 | // URI with incorrect scheme: auto-corrected |
| 73 | BOOST_CHECK_EQUAL(Name("ncc:/hello/world").toUri(), "/hello/world"); |
| 74 | |
| 75 | // URI with authority: authority ignored |
| 76 | BOOST_CHECK_EQUAL(Name("//authority/hello/world").toUri(), "/hello/world"); |
| 77 | BOOST_CHECK_EQUAL(Name("ndn://authority/hello/world").toUri(), "/hello/world"); |
| 78 | |
| 79 | // URI containing unescaped characters: auto-corrected |
| 80 | BOOST_CHECK_EQUAL(Name("/ hello\t/\tworld \r\n").toUri(), "/%20hello%09/%09world%20%0D%0A"); |
| 81 | BOOST_CHECK_EQUAL(Name("/hello/world/ ").toUri(), "/hello/world/%20%20"); |
| 82 | BOOST_CHECK_EQUAL(Name("/:?#[]@").toUri(), "/%3A%3F%23%5B%5D%40"); |
| 83 | |
| 84 | // URI not starting with '/': accepted as PartialName |
| 85 | BOOST_CHECK_EQUAL(Name("").toUri(), "/"); |
| 86 | BOOST_CHECK_EQUAL(Name(" ").toUri(), "/%20"); |
| 87 | BOOST_CHECK_EQUAL(Name(" /hello/world").toUri(), "/%20%20/hello/world"); |
| 88 | BOOST_CHECK_EQUAL(Name("hello/world").toUri(), "/hello/world"); |
| 89 | |
| 90 | // URI ending with '/': auto-corrected |
| 91 | BOOST_CHECK_EQUAL(Name("/hello/world/").toUri(), "/hello/world"); |
| 92 | |
| 93 | // URI containing bad component: rejected |
Alexander Afanasyev | d7eacc7 | 2015-04-03 13:06:26 -0700 | [diff] [blame] | 94 | BOOST_CHECK_THROW(Name("/hello//world"), name::Component::Error); |
Junxiao Shi | 9c9672e | 2018-04-18 12:55:08 +0000 | [diff] [blame] | 95 | BOOST_CHECK_THROW(Name("/hello/./world"), name::Component::Error); |
| 96 | BOOST_CHECK_THROW(Name("/hello/../world"), name::Component::Error); |
Alexander Afanasyev | d7eacc7 | 2015-04-03 13:06:26 -0700 | [diff] [blame] | 97 | } |
| 98 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 99 | BOOST_AUTO_TEST_CASE(DeepCopy) |
| 100 | { |
| 101 | Name n1("/hello/world"); |
| 102 | Name n2 = n1.deepCopy(); |
| 103 | |
| 104 | BOOST_CHECK_EQUAL(n1, n2); |
| 105 | BOOST_CHECK_NE(&n1.wireEncode(), &n2.wireEncode()); |
| 106 | |
| 107 | EncodingBuffer buffer(1024, 0); |
| 108 | n1.wireEncode(buffer); |
| 109 | Name n3(buffer.block()); |
| 110 | |
| 111 | BOOST_CHECK_EQUAL(n1, n3); |
| 112 | BOOST_CHECK_EQUAL(n3.wireEncode().getBuffer()->size(), 1024); |
| 113 | n3 = n3.deepCopy(); |
| 114 | |
| 115 | BOOST_CHECK_LT(n3.wireEncode().size(), 1024); |
| 116 | BOOST_CHECK_EQUAL(n3.wireEncode().getBuffer()->size(), n3.wireEncode().size()); |
| 117 | } |
| 118 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 119 | // ---- access ---- |
| 120 | |
| 121 | BOOST_AUTO_TEST_CASE(At) |
| 122 | { |
| 123 | Name name("/hello/5=NDN"); |
| 124 | |
| 125 | BOOST_CHECK_EQUAL(name.at(0), name::Component("080568656C6C6F"_block)); |
| 126 | BOOST_CHECK_EQUAL(name.at(1), name::Component("05034E444E"_block)); |
| 127 | BOOST_CHECK_EQUAL(name.at(-1), name::Component("05034E444E"_block)); |
| 128 | BOOST_CHECK_EQUAL(name.at(-2), name::Component("080568656C6C6F"_block)); |
| 129 | |
| 130 | BOOST_CHECK_THROW(name.at(2), Name::Error); |
| 131 | BOOST_CHECK_THROW(name.at(-3), Name::Error); |
| 132 | } |
| 133 | |
| 134 | BOOST_AUTO_TEST_CASE(SubName) |
| 135 | { |
| 136 | Name name("/hello/world"); |
| 137 | |
| 138 | BOOST_CHECK_EQUAL("/hello/world", name.getSubName(0)); |
| 139 | BOOST_CHECK_EQUAL("/world", name.getSubName(1)); |
Junxiao Shi | 9c9672e | 2018-04-18 12:55:08 +0000 | [diff] [blame] | 140 | BOOST_CHECK_EQUAL("/hello", name.getSubName(0, 1)); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 141 | } |
| 142 | |
| 143 | BOOST_AUTO_TEST_CASE(SubNameNegativeIndex) |
| 144 | { |
| 145 | Name name("/first/second/third/last"); |
| 146 | |
| 147 | BOOST_CHECK_EQUAL("/last", name.getSubName(-1)); |
| 148 | BOOST_CHECK_EQUAL("/third/last", name.getSubName(-2)); |
| 149 | BOOST_CHECK_EQUAL("/second", name.getSubName(-3, 1)); |
| 150 | } |
| 151 | |
| 152 | BOOST_AUTO_TEST_CASE(SubNameOutOfRangeIndexes) |
| 153 | { |
| 154 | Name name("/first/second/last"); |
| 155 | // No length |
| 156 | BOOST_CHECK_EQUAL("/first/second/last", name.getSubName(-10)); |
| 157 | BOOST_CHECK_EQUAL("/", name.getSubName(10)); |
| 158 | |
| 159 | // Starting after the max position |
| 160 | BOOST_CHECK_EQUAL("/", name.getSubName(10, 1)); |
| 161 | BOOST_CHECK_EQUAL("/", name.getSubName(10, 10)); |
| 162 | |
| 163 | // Not enough components |
| 164 | BOOST_CHECK_EQUAL("/second/last", name.getSubName(1, 10)); |
| 165 | BOOST_CHECK_EQUAL("/last", name.getSubName(-1, 10)); |
| 166 | |
| 167 | // Start before first |
| 168 | BOOST_CHECK_EQUAL("/first/second", name.getSubName(-10, 2)); |
| 169 | BOOST_CHECK_EQUAL("/first/second/last", name.getSubName(-10, 10)); |
| 170 | } |
| 171 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 172 | // ---- iterators ---- |
| 173 | |
| 174 | BOOST_AUTO_TEST_CASE(ForwardIterator) |
| 175 | { |
| 176 | name::Component comps[] { |
| 177 | name::Component("A"), |
| 178 | name::Component("B"), |
| 179 | name::Component("C"), |
| 180 | name::Component("D") |
| 181 | }; |
| 182 | |
| 183 | Name n0; |
| 184 | BOOST_CHECK_EQUAL_COLLECTIONS(n0.begin(), n0.end(), comps, comps + 0); |
| 185 | |
| 186 | Name n4("/A/B/C/D"); |
| 187 | BOOST_CHECK_EQUAL_COLLECTIONS(n4.begin(), n4.end(), comps, comps + 4); |
| 188 | } |
| 189 | |
| 190 | BOOST_AUTO_TEST_CASE(ReverseIterator) |
| 191 | { |
| 192 | name::Component comps[] { |
| 193 | name::Component("D"), |
| 194 | name::Component("C"), |
| 195 | name::Component("B"), |
| 196 | name::Component("A") |
| 197 | }; |
| 198 | |
| 199 | Name n0; |
| 200 | BOOST_CHECK_EQUAL_COLLECTIONS(n0.rbegin(), n0.rend(), comps, comps + 0); |
| 201 | |
| 202 | Name n4("/A/B/C/D"); |
| 203 | BOOST_CHECK_EQUAL_COLLECTIONS(n4.rbegin(), n4.rend(), comps, comps + 4); |
| 204 | } |
| 205 | |
| 206 | // ---- modifiers ---- |
| 207 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 208 | BOOST_AUTO_TEST_CASE(SetComponent) |
| 209 | { |
| 210 | Name name("/A/B"); |
| 211 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080141 080142"_block); |
| 212 | BOOST_CHECK_EQUAL(name.hasWire(), true); |
| 213 | |
| 214 | // pass by const lvalue ref |
| 215 | const Component c("C"); |
| 216 | name.set(0, c); |
| 217 | BOOST_CHECK_EQUAL(name.hasWire(), false); |
| 218 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080143 080142"_block); |
| 219 | |
| 220 | // pass by rvalue ref |
| 221 | Component d("D"); |
| 222 | name.set(1, std::move(d)); |
| 223 | BOOST_CHECK_EQUAL(name.hasWire(), false); |
| 224 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080143 080144"_block); |
| 225 | |
| 226 | // negative index |
| 227 | name.set(-1, Component("E")); |
| 228 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080143 080145"_block); |
| 229 | } |
| 230 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 231 | BOOST_AUTO_TEST_CASE(AppendComponent) |
Joao Pereira | 6f7cfd0 | 2015-06-15 11:36:26 -0400 | [diff] [blame] | 232 | { |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 233 | Name name; |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 234 | BOOST_CHECK_EQUAL(name.wireEncode(), "0700"_block); |
Ashlesh Gawande | 7dffab6 | 2017-12-21 16:40:53 -0600 | [diff] [blame] | 235 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 236 | name.append(Component("Emid")); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 237 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 0804456D6964"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 238 | |
Davide Pesavento | df8fd8a | 2022-02-21 20:04:21 -0500 | [diff] [blame] | 239 | name.append(25042, {'P', '3'}); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 240 | BOOST_CHECK_EQUAL(name.wireEncode(), "070C 0804456D6964 FD61D2025033"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 241 | |
Davide Pesavento | df8fd8a | 2022-02-21 20:04:21 -0500 | [diff] [blame] | 242 | name.append(Component(make_span<uint8_t>({'.'}))); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 243 | BOOST_CHECK_EQUAL(name.wireEncode(), "070F 0804456D6964 FD61D2025033 08012E"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 244 | |
Davide Pesavento | df8fd8a | 2022-02-21 20:04:21 -0500 | [diff] [blame] | 245 | const std::vector<uint8_t> v1{0x28, 0xF0, 0xA3, 0x6B}; |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 246 | name.append(16, v1.begin(), v1.end()); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 247 | BOOST_CHECK_EQUAL(name.wireEncode(), "0715 0804456D6964 FD61D2025033 08012E 100428F0A36B"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 248 | |
| 249 | BOOST_CHECK(!name.empty()); |
| 250 | name.clear(); |
| 251 | BOOST_CHECK(name.empty()); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 252 | BOOST_CHECK_EQUAL(name.wireEncode(), "0700"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 253 | |
| 254 | name.append(v1.begin(), v1.end()); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 255 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080428F0A36B"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 256 | |
| 257 | name.append("xKh"); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 258 | BOOST_CHECK_EQUAL(name.wireEncode(), "070B 080428F0A36B 0803784B68"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 259 | |
Davide Pesavento | fbea4fc | 2022-02-08 07:26:04 -0500 | [diff] [blame] | 260 | #pragma GCC diagnostic push |
| 261 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 262 | name.append("0100"_block); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 263 | BOOST_CHECK_EQUAL(name.wireEncode(), "070F 080428F0A36B 0803784B68 08020100"_block); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 264 | |
| 265 | name.append("080109"_block); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 266 | BOOST_CHECK_EQUAL(name.wireEncode(), "0712 080428F0A36B 0803784B68 08020100 080109"_block); |
Davide Pesavento | fbea4fc | 2022-02-08 07:26:04 -0500 | [diff] [blame] | 267 | #pragma GCC diagnostic pop |
Joao Pereira | 6f7cfd0 | 2015-06-15 11:36:26 -0400 | [diff] [blame] | 268 | } |
| 269 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 270 | BOOST_AUTO_TEST_CASE(AppendPartialName) |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 271 | { |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 272 | Name name("/A/B"); |
| 273 | name.append(PartialName("/6=C/D")) |
| 274 | .append(PartialName("/E")); |
Junxiao Shi | 72c0c64 | 2018-04-20 15:41:09 +0000 | [diff] [blame] | 275 | BOOST_CHECK_EQUAL(name.wireEncode(), "070F 080141 080142 060143 080144 080145"_block); |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 276 | |
| 277 | name = "/A/B"; |
| 278 | name.append(name); |
| 279 | BOOST_CHECK_EQUAL(name.wireEncode(), "070C 080141 080142 080141 080142"_block); |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | BOOST_AUTO_TEST_CASE(AppendNumber) |
| 283 | { |
| 284 | Name name; |
| 285 | for (uint32_t i = 0; i < 10; i++) { |
| 286 | name.appendNumber(i); |
| 287 | } |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 288 | BOOST_CHECK_EQUAL(name.size(), 10); |
| 289 | |
| 290 | for (uint32_t i = 0; i < 10; i++) { |
| 291 | BOOST_CHECK_EQUAL(name[i].toNumber(), i); |
| 292 | } |
| 293 | } |
| 294 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 295 | BOOST_AUTO_TEST_CASE(AppendParametersSha256Digest) |
| 296 | { |
| 297 | auto digest = make_shared<Buffer>(32); |
| 298 | |
| 299 | Name name("/P"); |
Davide Pesavento | 765abc9 | 2021-12-27 00:44:04 -0500 | [diff] [blame] | 300 | name.appendParametersSha256Digest(digest); // ConstBufferPtr overload |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 301 | BOOST_CHECK_EQUAL(name.wireEncode(), |
| 302 | "0725 080150 02200000000000000000000000000000000000000000000000000000000000000000"_block); |
| 303 | |
| 304 | name = "/P"; |
Davide Pesavento | 765abc9 | 2021-12-27 00:44:04 -0500 | [diff] [blame] | 305 | name.appendParametersSha256Digest(*digest); // span overload |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 306 | BOOST_CHECK_EQUAL(name.wireEncode(), |
| 307 | "0725 080150 02200000000000000000000000000000000000000000000000000000000000000000"_block); |
| 308 | |
| 309 | name = "/P"; |
| 310 | name.appendParametersSha256DigestPlaceholder(); |
| 311 | BOOST_CHECK_EQUAL(name.wireEncode(), |
| 312 | "0725 080150 0220E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855"_block); |
| 313 | } |
| 314 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 315 | BOOST_AUTO_TEST_CASE(Markers) |
| 316 | { |
| 317 | // TestNameComponent/NamingConvention provides additional coverage for these methods, |
| 318 | // including verifications of the wire format. |
| 319 | |
| 320 | Name name; |
| 321 | uint64_t number; |
| 322 | |
| 323 | BOOST_REQUIRE_NO_THROW(number = name.appendSegment(30923).at(-1).toSegment()); |
| 324 | BOOST_CHECK_EQUAL(number, 30923); |
| 325 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 326 | BOOST_REQUIRE_NO_THROW(number = name.appendVersion().at(-1).toVersion()); |
| 327 | |
| 328 | BOOST_REQUIRE_NO_THROW(number = name.appendVersion(25912).at(-1).toVersion()); |
| 329 | BOOST_CHECK_EQUAL(number, 25912); |
| 330 | |
Davide Pesavento | 46cdf90 | 2020-06-08 16:38:23 -0400 | [diff] [blame] | 331 | const auto tp = time::system_clock::now(); |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 332 | time::system_clock::TimePoint tp2; |
| 333 | BOOST_REQUIRE_NO_THROW(tp2 = name.appendTimestamp(tp).at(-1).toTimestamp()); |
Davide Pesavento | 009062d | 2019-11-20 00:16:33 -0500 | [diff] [blame] | 334 | BOOST_CHECK_LE(time::abs(tp2 - tp), 1_us); |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 335 | |
| 336 | BOOST_REQUIRE_NO_THROW(number = name.appendSequenceNumber(11676).at(-1).toSequenceNumber()); |
| 337 | BOOST_CHECK_EQUAL(number, 11676); |
| 338 | } |
| 339 | |
Davide Pesavento | adc9aa2 | 2019-06-30 19:00:20 -0400 | [diff] [blame] | 340 | BOOST_AUTO_TEST_CASE(EraseComponent) |
| 341 | { |
| 342 | Name name("/A/B/C"); |
| 343 | BOOST_CHECK_EQUAL(name.wireEncode(), "0709 080141 080142 080143"_block); |
| 344 | BOOST_CHECK_EQUAL(name.hasWire(), true); |
| 345 | |
| 346 | name.erase(1); |
| 347 | BOOST_CHECK_EQUAL(name.size(), 2); |
| 348 | BOOST_CHECK_EQUAL(name.hasWire(), false); |
| 349 | BOOST_CHECK_EQUAL(name.wireEncode(), "0706 080141 080143"_block); |
| 350 | |
| 351 | name.erase(-1); |
| 352 | BOOST_CHECK_EQUAL(name.size(), 1); |
| 353 | BOOST_CHECK_EQUAL(name.hasWire(), false); |
| 354 | BOOST_CHECK_EQUAL(name.wireEncode(), "0703 080141"_block); |
| 355 | } |
| 356 | |
| 357 | BOOST_AUTO_TEST_CASE(Clear) |
| 358 | { |
| 359 | Name name("/A/B/C"); |
| 360 | BOOST_CHECK_EQUAL(name.empty(), false); |
| 361 | name.clear(); |
| 362 | BOOST_CHECK_EQUAL(name.empty(), true); |
| 363 | BOOST_CHECK(name.begin() == name.end()); |
| 364 | } |
| 365 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 366 | // ---- algorithms ---- |
| 367 | |
| 368 | BOOST_AUTO_TEST_CASE(GetSuccessor) |
| 369 | { |
Junxiao Shi | cf0aff8 | 2018-07-23 06:42:13 -0600 | [diff] [blame] | 370 | BOOST_CHECK_EQUAL(Name().getSuccessor(), "/sha256digest=0000000000000000000000000000000000000000000000000000000000000000"); |
| 371 | BOOST_CHECK_EQUAL(Name("/sha256digest=0000000000000000000000000000000000000000000000000000000000000000").getSuccessor(), |
| 372 | "/sha256digest=0000000000000000000000000000000000000000000000000000000000000001"); |
| 373 | BOOST_CHECK_EQUAL(Name("/sha256digest=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").getSuccessor(), |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 374 | "/params-sha256=0000000000000000000000000000000000000000000000000000000000000000"); |
| 375 | BOOST_CHECK_EQUAL(Name("/params-sha256=0000000000000000000000000000000000000000000000000000000000000000").getSuccessor(), |
| 376 | "/params-sha256=0000000000000000000000000000000000000000000000000000000000000001"); |
| 377 | BOOST_CHECK_EQUAL(Name("/params-sha256=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").getSuccessor(), |
| 378 | "/3=..."); |
Junxiao Shi | cf0aff8 | 2018-07-23 06:42:13 -0600 | [diff] [blame] | 379 | BOOST_CHECK_EQUAL(Name("/P/A").getSuccessor(), "/P/B"); |
| 380 | BOOST_CHECK_EQUAL(Name("/P/AAA").getSuccessor(), "/P/AAB"); |
| 381 | BOOST_CHECK_EQUAL(Name("/Q/...").getSuccessor(), "/Q/%00"); |
| 382 | BOOST_CHECK_EQUAL(Name("/Q/%FF").getSuccessor(), "/Q/%00%00"); |
| 383 | BOOST_CHECK_EQUAL(Name("/Q/%FE%FF").getSuccessor(), "/Q/%FF%00"); |
| 384 | BOOST_CHECK_EQUAL(Name("/Q/%FF%FF").getSuccessor(), "/Q/%00%00%00"); |
| 385 | BOOST_CHECK_EQUAL(Name("/P/3=A").getSuccessor(), "/P/3=B"); |
| 386 | BOOST_CHECK_EQUAL(Name("/P/3=AAA").getSuccessor(), "/P/3=AAB"); |
| 387 | BOOST_CHECK_EQUAL(Name("/Q/3=...").getSuccessor(), "/Q/3=%00"); |
| 388 | BOOST_CHECK_EQUAL(Name("/Q/3=%FF").getSuccessor(), "/Q/3=%00%00"); |
| 389 | BOOST_CHECK_EQUAL(Name("/Q/3=%FE%FF").getSuccessor(), "/Q/3=%FF%00"); |
| 390 | BOOST_CHECK_EQUAL(Name("/Q/3=%FF%FF").getSuccessor(), "/Q/3=%00%00%00"); |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 391 | } |
| 392 | |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 393 | BOOST_AUTO_TEST_CASE(IsPrefixOf) |
| 394 | { |
| 395 | BOOST_CHECK(Name("/").isPrefixOf("/")); |
| 396 | BOOST_CHECK(Name("/").isPrefixOf("/sha256digest=0000000000000000000000000000000000000000000000000000000000000000")); |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 397 | BOOST_CHECK(Name("/").isPrefixOf("/params-sha256=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); |
| 398 | BOOST_CHECK(Name("/").isPrefixOf("/3=D")); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 399 | BOOST_CHECK(Name("/").isPrefixOf("/F")); |
| 400 | BOOST_CHECK(Name("/").isPrefixOf("/21426=AA")); |
| 401 | |
| 402 | BOOST_CHECK(Name("/B").isPrefixOf("/B")); |
| 403 | BOOST_CHECK(Name("/B").isPrefixOf("/B/sha256digest=0000000000000000000000000000000000000000000000000000000000000000")); |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 404 | BOOST_CHECK(Name("/").isPrefixOf("/B/params-sha256=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); |
| 405 | BOOST_CHECK(Name("/B").isPrefixOf("/B/3=D")); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 406 | BOOST_CHECK(Name("/B").isPrefixOf("/B/F")); |
| 407 | BOOST_CHECK(Name("/B").isPrefixOf("/B/21426=AA")); |
| 408 | |
| 409 | BOOST_CHECK(!Name("/C").isPrefixOf("/")); |
| 410 | BOOST_CHECK(!Name("/C").isPrefixOf("/sha256digest=0000000000000000000000000000000000000000000000000000000000000000")); |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 411 | BOOST_CHECK(Name("/").isPrefixOf("/params-sha256=ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); |
| 412 | BOOST_CHECK(!Name("/C").isPrefixOf("/3=D")); |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 413 | BOOST_CHECK(!Name("/C").isPrefixOf("/F")); |
| 414 | BOOST_CHECK(!Name("/C").isPrefixOf("/21426=AA")); |
| 415 | } |
| 416 | |
| 417 | BOOST_AUTO_TEST_CASE(CompareOp) |
| 418 | { |
| 419 | std::vector<Name> names = { |
| 420 | Name("/"), |
| 421 | Name("/sha256digest=0000000000000000000000000000000000000000000000000000000000000000"), |
| 422 | Name("/sha256digest=0000000000000000000000000000000000000000000000000000000000000001"), |
| 423 | Name("/sha256digest=FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 424 | Name("/params-sha256=0000000000000000000000000000000000000000000000000000000000000000"), |
| 425 | Name("/params-sha256=0000000000000000000000000000000000000000000000000000000000000001"), |
| 426 | Name("/params-sha256=FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), |
| 427 | Name("/3=..."), |
| 428 | Name("/3=D"), |
| 429 | Name("/3=F"), |
| 430 | Name("/3=AA"), |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 431 | Name("/..."), |
| 432 | Name("/D"), |
| 433 | Name("/D/sha256digest=0000000000000000000000000000000000000000000000000000000000000000"), |
| 434 | Name("/D/sha256digest=0000000000000000000000000000000000000000000000000000000000000001"), |
| 435 | Name("/D/sha256digest=FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), |
Junxiao Shi | 4053bd5 | 2018-08-16 13:39:25 -0600 | [diff] [blame] | 436 | Name("/D/params-sha256=0000000000000000000000000000000000000000000000000000000000000000"), |
| 437 | Name("/D/params-sha256=0000000000000000000000000000000000000000000000000000000000000001"), |
| 438 | Name("/D/params-sha256=FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), |
| 439 | Name("/D/3=..."), |
| 440 | Name("/D/3=D"), |
| 441 | Name("/D/3=F"), |
| 442 | Name("/D/3=AA"), |
Junxiao Shi | a36f15d | 2018-04-04 02:22:11 +0000 | [diff] [blame] | 443 | Name("/D/..."), |
| 444 | Name("/D/D"), |
| 445 | Name("/D/F"), |
| 446 | Name("/D/AA"), |
| 447 | Name("/D/21426=..."), |
| 448 | Name("/D/21426=D"), |
| 449 | Name("/D/21426=F"), |
| 450 | Name("/D/21426=AA"), |
| 451 | Name("/F"), |
| 452 | Name("/AA"), |
| 453 | Name("/21426=..."), |
| 454 | Name("/21426=D"), |
| 455 | Name("/21426=F"), |
| 456 | Name("/21426=AA"), |
| 457 | }; |
| 458 | |
| 459 | for (size_t i = 0; i < names.size(); ++i) { |
| 460 | for (size_t j = 0; j < names.size(); ++j) { |
| 461 | Name lhs = names[i]; |
| 462 | Name rhs = names[j]; |
| 463 | BOOST_CHECK_EQUAL(lhs == rhs, i == j); |
| 464 | BOOST_CHECK_EQUAL(lhs != rhs, i != j); |
| 465 | BOOST_CHECK_EQUAL(lhs < rhs, i < j); |
| 466 | BOOST_CHECK_EQUAL(lhs <= rhs, i <= j); |
| 467 | BOOST_CHECK_EQUAL(lhs > rhs, i > j); |
| 468 | BOOST_CHECK_EQUAL(lhs >= rhs, i >= j); |
| 469 | } |
| 470 | } |
| 471 | } |
| 472 | |
| 473 | BOOST_AUTO_TEST_CASE(CompareFunc) |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 474 | { |
| 475 | BOOST_CHECK_EQUAL(Name("/A") .compare(Name("/A")), 0); |
| 476 | BOOST_CHECK_LT (Name("/A") .compare(Name("/B")), 0); |
| 477 | BOOST_CHECK_GT (Name("/B") .compare(Name("/A")), 0); |
| 478 | BOOST_CHECK_LT (Name("/A") .compare(Name("/AA")), 0); |
| 479 | BOOST_CHECK_GT (Name("/AA") .compare(Name("/A")), 0); |
| 480 | BOOST_CHECK_LT (Name("/A") .compare(Name("/A/C")), 0); |
| 481 | BOOST_CHECK_GT (Name("/A/C").compare(Name("/A")), 0); |
| 482 | |
| 483 | BOOST_CHECK_EQUAL(Name("/Z/A/Y") .compare(1, 1, Name("/A")), 0); |
| 484 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/B")), 0); |
| 485 | BOOST_CHECK_GT (Name("/Z/B/Y") .compare(1, 1, Name("/A")), 0); |
| 486 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/AA")), 0); |
| 487 | BOOST_CHECK_GT (Name("/Z/AA/Y") .compare(1, 1, Name("/A")), 0); |
| 488 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/A/C")), 0); |
| 489 | BOOST_CHECK_GT (Name("/Z/A/C/Y").compare(1, 2, Name("/A")), 0); |
| 490 | |
| 491 | BOOST_CHECK_EQUAL(Name("/Z/A") .compare(1, Name::npos, Name("/A")), 0); |
| 492 | BOOST_CHECK_LT (Name("/Z/A") .compare(1, Name::npos, Name("/B")), 0); |
| 493 | BOOST_CHECK_GT (Name("/Z/B") .compare(1, Name::npos, Name("/A")), 0); |
| 494 | BOOST_CHECK_LT (Name("/Z/A") .compare(1, Name::npos, Name("/AA")), 0); |
| 495 | BOOST_CHECK_GT (Name("/Z/AA") .compare(1, Name::npos, Name("/A")), 0); |
| 496 | BOOST_CHECK_LT (Name("/Z/A") .compare(1, Name::npos, Name("/A/C")), 0); |
| 497 | BOOST_CHECK_GT (Name("/Z/A/C").compare(1, Name::npos, Name("/A")), 0); |
| 498 | |
| 499 | BOOST_CHECK_EQUAL(Name("/Z/A/Y") .compare(1, 1, Name("/X/A/W"), 1, 1), 0); |
| 500 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/B/W"), 1, 1), 0); |
| 501 | BOOST_CHECK_GT (Name("/Z/B/Y") .compare(1, 1, Name("/X/A/W"), 1, 1), 0); |
| 502 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/AA/W"), 1, 1), 0); |
| 503 | BOOST_CHECK_GT (Name("/Z/AA/Y") .compare(1, 1, Name("/X/A/W"), 1, 1), 0); |
| 504 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/A/C/W"), 1, 2), 0); |
| 505 | BOOST_CHECK_GT (Name("/Z/A/C/Y").compare(1, 2, Name("/X/A/W"), 1, 1), 0); |
| 506 | |
| 507 | BOOST_CHECK_EQUAL(Name("/Z/A/Y") .compare(1, 1, Name("/X/A"), 1), 0); |
| 508 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/B"), 1), 0); |
| 509 | BOOST_CHECK_GT (Name("/Z/B/Y") .compare(1, 1, Name("/X/A"), 1), 0); |
| 510 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/AA"), 1), 0); |
| 511 | BOOST_CHECK_GT (Name("/Z/AA/Y") .compare(1, 1, Name("/X/A"), 1), 0); |
| 512 | BOOST_CHECK_LT (Name("/Z/A/Y") .compare(1, 1, Name("/X/A/C"), 1), 0); |
| 513 | BOOST_CHECK_GT (Name("/Z/A/C/Y").compare(1, 2, Name("/X/A"), 1), 0); |
| 514 | } |
| 515 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 516 | BOOST_AUTO_TEST_CASE(UnorderedMap) |
Alexander Afanasyev | 4f512fb | 2016-05-18 10:47:53 -0700 | [diff] [blame] | 517 | { |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 518 | std::unordered_map<Name, int> map; |
| 519 | Name name1("/1"); |
| 520 | Name name2("/2"); |
| 521 | Name name3("/3"); |
| 522 | map[name1] = 1; |
| 523 | map[name2] = 2; |
| 524 | map[name3] = 3; |
Alexander Afanasyev | 4f512fb | 2016-05-18 10:47:53 -0700 | [diff] [blame] | 525 | |
Junxiao Shi | 71ff231 | 2017-07-12 13:32:50 +0000 | [diff] [blame] | 526 | BOOST_CHECK_EQUAL(map[name1], 1); |
| 527 | BOOST_CHECK_EQUAL(map[name2], 2); |
| 528 | BOOST_CHECK_EQUAL(map[name3], 3); |
Alexander Afanasyev | 4f512fb | 2016-05-18 10:47:53 -0700 | [diff] [blame] | 529 | } |
| 530 | |
Davide Pesavento | eee3e82 | 2016-11-26 19:19:34 +0100 | [diff] [blame] | 531 | BOOST_AUTO_TEST_SUITE_END() // TestName |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 532 | |
Junxiao Shi | 6bf0adf | 2015-02-15 13:54:56 -0700 | [diff] [blame] | 533 | } // namespace tests |
Alexander Afanasyev | 52eb20d | 2014-02-06 18:25:54 -0800 | [diff] [blame] | 534 | } // namespace ndn |