Line data Source code
1 : // Copyright (c) 2011-2019 Made to Order Software Corp. All Rights Reserved
2 : //
3 : // Project: https://snapwebsites.org/project/libaddr
4 : //
5 : // Permission is hereby granted, free of charge, to any
6 : // person obtaining a copy of this software and
7 : // associated documentation files (the "Software"), to
8 : // deal in the Software without restriction, including
9 : // without limitation the rights to use, copy, modify,
10 : // merge, publish, distribute, sublicense, and/or sell
11 : // copies of the Software, and to permit persons to whom
12 : // the Software is furnished to do so, subject to the
13 : // following conditions:
14 : //
15 : // The above copyright notice and this permission notice
16 : // shall be included in all copies or substantial
17 : // portions of the Software.
18 : //
19 : // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
20 : // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
21 : // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
22 : // FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
23 : // EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 : // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
25 : // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 : // ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 : // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 : // SOFTWARE.
29 :
30 :
31 : /** \file
32 : * \brief Check the addr_range class basics.
33 : *
34 : * This set of unit tests do basic verification of the range class.
35 : *
36 : * The point here is to test the range functionality and not the
37 : * addr_parser class.
38 : */
39 :
40 : #include "test_addr_main.h"
41 :
42 :
43 :
44 :
45 7 : CATCH_TEST_CASE( "ipv4::range", "[ipv4]" )
46 : {
47 10 : CATCH_GIVEN("addr_range()")
48 : {
49 3 : addr::addr_range range;
50 :
51 6 : CATCH_SECTION("verify defaults")
52 : {
53 1 : addr::addr a;
54 :
55 1 : CATCH_REQUIRE_FALSE(range.has_from());
56 1 : CATCH_REQUIRE_FALSE(range.has_to());
57 1 : CATCH_REQUIRE_FALSE(range.is_range());
58 1 : CATCH_REQUIRE_FALSE(range.is_empty());
59 : //std::cerr << "++++++++++++++++++ " << a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_PORT) << "\n";
60 : //std::cerr << "++++++++++++++++++ " << range.get_from().to_ipv6_string(addr::addr::string_ip_t::STRING_IP_PORT) << "\n";
61 : //
62 : //struct sockaddr_in6 in6_a;
63 : //a.get_ipv6(in6_a);
64 : //std::cerr << "++++++++++++++++++ in6 --" << std::hex;
65 : //for(size_t idx(0); idx < sizeof(in6_a); ++idx)
66 : // std::cerr << " " << static_cast<int>(reinterpret_cast<char *>(&in6_a)[idx]);
67 : //std::cerr << "\n";
68 : //
69 : //struct sockaddr_in6 in6_b;
70 : //range.get_from().get_ipv6(in6_b);
71 : //std::cerr << "++++++++++++++++++ in6 --" << std::hex;
72 : //for(size_t idx(0); idx < sizeof(in6_b); ++idx)
73 : // std::cerr << " " << static_cast<int>(reinterpret_cast<char *>(&in6_b)[idx]);
74 : //std::cerr << "\n";
75 1 : CATCH_REQUIRE(range.get_from() == a);
76 1 : CATCH_REQUIRE(range.get_to() == a);
77 :
78 : // to use the const version of the get_from/to() functions
79 : // we have to define a const refence to range
80 : //
81 1 : auto const & r(range);
82 1 : CATCH_REQUIRE(r.get_from() == a);
83 1 : CATCH_REQUIRE(r.get_to() == a);
84 :
85 1 : addr::addr other;
86 1 : CATCH_REQUIRE_THROWS_AS(range.is_in(other), addr::addr_invalid_state);
87 1 : CATCH_REQUIRE_THROWS_AS(r.is_in(other), addr::addr_invalid_state);
88 : }
89 :
90 6 : CATCH_SECTION("test normal range (from <= to)")
91 : {
92 1 : addr::addr a;
93 1 : addr::addr other;
94 :
95 : // from is set to 10.0.0.1
96 1 : struct sockaddr_in fin = sockaddr_in();
97 1 : fin.sin_family = AF_INET;
98 1 : fin.sin_port = htons(rand());
99 : uint32_t faddress((10 << 24)
100 : | (0 << 16)
101 : | (0 << 8)
102 1 : | 1);
103 1 : fin.sin_addr.s_addr = htonl(faddress);
104 1 : addr::addr f;
105 1 : f.set_ipv4(fin);
106 :
107 : // from is set to 10.0.0.254
108 1 : struct sockaddr_in tin = sockaddr_in();
109 1 : tin.sin_family = AF_INET;
110 1 : tin.sin_port = htons(rand());
111 : uint32_t taddress((10 << 24)
112 : | (0 << 16)
113 : | (0 << 8)
114 1 : | 254);
115 1 : tin.sin_addr.s_addr = htonl(taddress);
116 1 : addr::addr t;
117 1 : t.set_ipv4(tin);
118 :
119 : // test defaults first
120 : //
121 1 : CATCH_REQUIRE_FALSE(range.has_from());
122 1 : CATCH_REQUIRE_FALSE(range.has_to());
123 1 : CATCH_REQUIRE_FALSE(range.is_range());
124 1 : CATCH_REQUIRE_FALSE(range.is_empty());
125 1 : CATCH_REQUIRE(range.get_from() == a);
126 1 : CATCH_REQUIRE(range.get_to() == a);
127 1 : auto const & r1(range);
128 1 : CATCH_REQUIRE(r1.get_from() == a);
129 1 : CATCH_REQUIRE(r1.get_to() == a);
130 1 : CATCH_REQUIRE_THROWS_AS(range.is_in(other), addr::addr_invalid_state);
131 1 : CATCH_REQUIRE_THROWS_AS(r1.is_in(other), addr::addr_invalid_state);
132 1 : CATCH_REQUIRE(range.match(a));
133 1 : CATCH_REQUIRE_FALSE(range.match(f));
134 1 : CATCH_REQUIRE_FALSE(range.match(t));
135 :
136 1 : range.set_from(f);
137 :
138 : // defined "from", test the results
139 : //
140 1 : CATCH_REQUIRE(range.has_from());
141 1 : CATCH_REQUIRE_FALSE(range.has_to());
142 1 : CATCH_REQUIRE_FALSE(range.is_range());
143 1 : CATCH_REQUIRE_FALSE(range.is_empty());
144 1 : CATCH_REQUIRE(range.get_from() == f);
145 1 : CATCH_REQUIRE(range.get_to() == a);
146 1 : auto const & r2(range);
147 1 : CATCH_REQUIRE(r2.get_from() == f);
148 1 : CATCH_REQUIRE(r2.get_to() == a);
149 1 : CATCH_REQUIRE_THROWS_AS(range.is_in(other), addr::addr_invalid_state);
150 1 : CATCH_REQUIRE_THROWS_AS(r2.is_in(other), addr::addr_invalid_state);
151 1 : CATCH_REQUIRE_FALSE(range.match(a));
152 1 : CATCH_REQUIRE(range.match(f));
153 1 : CATCH_REQUIRE_FALSE(range.match(t));
154 :
155 1 : range.set_to(t);
156 :
157 : // defined "to", test the results
158 : //
159 1 : CATCH_REQUIRE(range.has_from());
160 1 : CATCH_REQUIRE(range.has_to());
161 1 : CATCH_REQUIRE(range.is_range());
162 1 : CATCH_REQUIRE_FALSE(range.is_empty());
163 1 : CATCH_REQUIRE(range.get_from() == f);
164 1 : CATCH_REQUIRE(range.get_to() == t);
165 1 : auto const & r3(range);
166 1 : CATCH_REQUIRE(r3.get_from() == f);
167 1 : CATCH_REQUIRE(r3.get_to() == t);
168 1 : CATCH_REQUIRE_FALSE(range.match(a));
169 1 : CATCH_REQUIRE(range.match(f));
170 1 : CATCH_REQUIRE(range.match(t));
171 :
172 : // IP before range
173 : {
174 1 : struct sockaddr_in bin = sockaddr_in();
175 1 : bin.sin_family = AF_INET;
176 1 : bin.sin_port = htons(rand());
177 : uint32_t baddress((10 << 24)
178 : | (0 << 16)
179 : | (0 << 8)
180 1 : | 0);
181 1 : bin.sin_addr.s_addr = htonl(baddress);
182 1 : addr::addr b;
183 1 : b.set_ipv4(bin);
184 :
185 1 : CATCH_REQUIRE_FALSE(range.is_in(b));
186 : }
187 :
188 11 : for(int idx(0); idx < 10; ++idx)
189 : {
190 10 : struct sockaddr_in bin = sockaddr_in();
191 10 : bin.sin_family = AF_INET;
192 10 : bin.sin_port = htons(rand());
193 10 : uint32_t baddress(((rand() % 10) << 24)
194 10 : | ((rand() & 255) << 16)
195 10 : | ((rand() & 255) << 8)
196 10 : | (rand() & 255));
197 10 : bin.sin_addr.s_addr = htonl(baddress);
198 10 : addr::addr b;
199 10 : b.set_ipv4(bin);
200 :
201 10 : CATCH_REQUIRE_FALSE(range.is_in(b));
202 : }
203 :
204 : // IP after range
205 : {
206 1 : struct sockaddr_in ain = sockaddr_in();
207 1 : ain.sin_family = AF_INET;
208 1 : ain.sin_port = htons(rand());
209 : uint32_t aaddress((10 << 24)
210 : | (0 << 16)
211 : | (0 << 8)
212 1 : | 255);
213 1 : ain.sin_addr.s_addr = htonl(aaddress);
214 1 : addr::addr after;
215 1 : after.set_ipv4(ain);
216 :
217 1 : CATCH_REQUIRE_FALSE(range.is_in(after));
218 : }
219 :
220 11 : for(int idx(0); idx < 10; ++idx)
221 : {
222 10 : struct sockaddr_in ain = sockaddr_in();
223 10 : ain.sin_family = AF_INET;
224 10 : ain.sin_port = htons(rand());
225 10 : uint32_t aaddress(((rand() % (256 - 11) + 11) << 24)
226 10 : | ((rand() & 255) << 16)
227 10 : | ((rand() & 255) << 8)
228 10 : | (rand() & 255));
229 10 : ain.sin_addr.s_addr = htonl(aaddress);
230 10 : addr::addr after;
231 10 : after.set_ipv4(ain);
232 :
233 10 : CATCH_REQUIRE_FALSE(range.is_in(after));
234 : }
235 :
236 : // IP in range
237 : //
238 255 : for(int idx(1); idx < 255; ++idx)
239 : {
240 254 : struct sockaddr_in iin = sockaddr_in();
241 254 : iin.sin_family = AF_INET;
242 254 : iin.sin_port = htons(rand());
243 : uint32_t iaddress((10 << 24)
244 : | (0 << 16)
245 : | (0 << 8)
246 254 : | idx);
247 254 : iin.sin_addr.s_addr = htonl(iaddress);
248 254 : addr::addr i;
249 254 : i.set_ipv4(iin);
250 :
251 254 : CATCH_REQUIRE(range.is_in(i));
252 : }
253 : }
254 :
255 6 : CATCH_SECTION("test empty range (from > to)")
256 : {
257 1 : addr::addr a;
258 1 : addr::addr other;
259 :
260 : // from is set to 10.0.0.254
261 1 : struct sockaddr_in fin = sockaddr_in();
262 1 : fin.sin_family = AF_INET;
263 1 : fin.sin_port = htons(rand());
264 : uint32_t faddress((10 << 24)
265 : | (0 << 16)
266 : | (0 << 8)
267 1 : | 254);
268 1 : fin.sin_addr.s_addr = htonl(faddress);
269 1 : addr::addr f;
270 1 : f.set_ipv4(fin);
271 :
272 : // from is set to 10.0.0.1
273 1 : struct sockaddr_in tin = sockaddr_in();
274 1 : tin.sin_family = AF_INET;
275 1 : tin.sin_port = htons(rand());
276 : uint32_t taddress((10 << 24)
277 : | (0 << 16)
278 : | (0 << 8)
279 1 : | 1);
280 1 : tin.sin_addr.s_addr = htonl(taddress);
281 1 : addr::addr t;
282 1 : t.set_ipv4(tin);
283 :
284 : // test defaults first
285 : //
286 1 : CATCH_REQUIRE_FALSE(range.has_from());
287 1 : CATCH_REQUIRE_FALSE(range.has_to());
288 1 : CATCH_REQUIRE_FALSE(range.is_range());
289 1 : CATCH_REQUIRE_FALSE(range.is_empty());
290 1 : CATCH_REQUIRE(range.get_from() == a);
291 1 : CATCH_REQUIRE(range.get_to() == a);
292 1 : auto const & r1(range);
293 1 : CATCH_REQUIRE(r1.get_from() == a);
294 1 : CATCH_REQUIRE(r1.get_to() == a);
295 1 : CATCH_REQUIRE_THROWS_AS(range.is_in(other), addr::addr_invalid_state);
296 1 : CATCH_REQUIRE_THROWS_AS(r1.is_in(other), addr::addr_invalid_state);
297 1 : CATCH_REQUIRE(range.match(a));
298 1 : CATCH_REQUIRE_FALSE(range.match(f));
299 1 : CATCH_REQUIRE_FALSE(range.match(t));
300 :
301 1 : range.set_from(f);
302 :
303 : // defined "from", test the results
304 : //
305 1 : CATCH_REQUIRE(range.has_from());
306 1 : CATCH_REQUIRE_FALSE(range.has_to());
307 1 : CATCH_REQUIRE_FALSE(range.is_range());
308 1 : CATCH_REQUIRE_FALSE(range.is_empty());
309 1 : CATCH_REQUIRE(range.get_from() == f);
310 1 : CATCH_REQUIRE(range.get_to() == a);
311 1 : auto const & r2(range);
312 1 : CATCH_REQUIRE(r2.get_from() == f);
313 1 : CATCH_REQUIRE(r2.get_to() == a);
314 1 : CATCH_REQUIRE_THROWS_AS(range.is_in(other), addr::addr_invalid_state);
315 1 : CATCH_REQUIRE_THROWS_AS(r2.is_in(other), addr::addr_invalid_state);
316 1 : CATCH_REQUIRE_FALSE(range.match(a));
317 1 : CATCH_REQUIRE(range.match(f));
318 1 : CATCH_REQUIRE_FALSE(range.match(t));
319 :
320 1 : range.set_to(t);
321 :
322 : // defined "to", test the results
323 : //
324 1 : CATCH_REQUIRE(range.has_from());
325 1 : CATCH_REQUIRE(range.has_to());
326 1 : CATCH_REQUIRE(range.is_range());
327 1 : CATCH_REQUIRE(range.is_empty());
328 1 : CATCH_REQUIRE(range.get_from() == f);
329 1 : CATCH_REQUIRE(range.get_to() == t);
330 1 : auto const & r3(range);
331 1 : CATCH_REQUIRE(r3.get_from() == f);
332 1 : CATCH_REQUIRE(r3.get_to() == t);
333 1 : CATCH_REQUIRE_FALSE(range.match(a));
334 1 : CATCH_REQUIRE_FALSE(range.match(f));
335 1 : CATCH_REQUIRE_FALSE(range.match(t));
336 :
337 : // IP before range
338 : {
339 1 : struct sockaddr_in bin = sockaddr_in();
340 1 : bin.sin_family = AF_INET;
341 1 : bin.sin_port = htons(rand());
342 : uint32_t baddress((10 << 24)
343 : | (0 << 16)
344 : | (0 << 8)
345 1 : | 0);
346 1 : bin.sin_addr.s_addr = htonl(baddress);
347 1 : addr::addr b;
348 1 : b.set_ipv4(bin);
349 :
350 1 : CATCH_REQUIRE_FALSE(range.is_in(b));
351 : }
352 :
353 11 : for(int idx(0); idx < 10; ++idx)
354 : {
355 10 : struct sockaddr_in bin = sockaddr_in();
356 10 : bin.sin_family = AF_INET;
357 10 : bin.sin_port = htons(rand());
358 10 : uint32_t baddress(((rand() % 10) << 24)
359 10 : | ((rand() & 255) << 16)
360 10 : | ((rand() & 255) << 8)
361 10 : | (rand() & 255));
362 10 : bin.sin_addr.s_addr = htonl(baddress);
363 10 : addr::addr b;
364 10 : b.set_ipv4(bin);
365 :
366 10 : CATCH_REQUIRE_FALSE(range.is_in(b));
367 : }
368 :
369 : // IP after range
370 : {
371 1 : struct sockaddr_in ain = sockaddr_in();
372 1 : ain.sin_family = AF_INET;
373 1 : ain.sin_port = htons(rand());
374 : uint32_t aaddress((10 << 24)
375 : | (0 << 16)
376 : | (0 << 8)
377 1 : | 255);
378 1 : ain.sin_addr.s_addr = htonl(aaddress);
379 1 : addr::addr after;
380 1 : after.set_ipv4(ain);
381 :
382 1 : CATCH_REQUIRE_FALSE(range.is_in(after));
383 : }
384 :
385 11 : for(int idx(0); idx < 10; ++idx)
386 : {
387 10 : struct sockaddr_in ain = sockaddr_in();
388 10 : ain.sin_family = AF_INET;
389 10 : ain.sin_port = htons(rand());
390 10 : uint32_t aaddress(((rand() % (256 - 11) + 11) << 24)
391 10 : | ((rand() & 255) << 16)
392 10 : | ((rand() & 255) << 8)
393 10 : | (rand() & 255));
394 10 : ain.sin_addr.s_addr = htonl(aaddress);
395 10 : addr::addr after;
396 10 : after.set_ipv4(ain);
397 :
398 10 : CATCH_REQUIRE_FALSE(range.is_in(after));
399 : }
400 :
401 : // IP in range
402 : //
403 101 : for(int idx(0); idx < 100; ++idx)
404 : {
405 100 : struct sockaddr_in iin = sockaddr_in();
406 100 : iin.sin_family = AF_INET;
407 100 : iin.sin_port = htons(rand());
408 : uint32_t iaddress((10 << 24)
409 : | (0 << 16)
410 : | (0 << 8)
411 100 : | ((rand() & 253) + 1));
412 100 : iin.sin_addr.s_addr = htonl(iaddress);
413 100 : addr::addr i;
414 100 : i.set_ipv4(iin);
415 :
416 100 : CATCH_REQUIRE_FALSE(range.is_in(i));
417 : }
418 : }
419 : }
420 :
421 10 : CATCH_GIVEN("compute intersection of two ranges")
422 : {
423 4 : CATCH_SECTION("two ranges that overlap")
424 : {
425 : // from is set to 10.1.0.0
426 1 : struct sockaddr_in f1in = sockaddr_in();
427 1 : f1in.sin_family = AF_INET;
428 1 : f1in.sin_port = htons(rand());
429 : uint32_t f1address((10 << 24)
430 : | (1 << 16)
431 : | (0 << 8)
432 1 : | 0);
433 1 : f1in.sin_addr.s_addr = htonl(f1address);
434 1 : addr::addr f1;
435 1 : f1.set_ipv4(f1in);
436 :
437 : // from is set to 10.5.255.255
438 1 : struct sockaddr_in t1in = sockaddr_in();
439 1 : t1in.sin_family = AF_INET;
440 1 : t1in.sin_port = htons(rand());
441 : uint32_t t1address((10 << 24)
442 : | (5 << 16)
443 : | (255 << 8)
444 1 : | 255);
445 1 : t1in.sin_addr.s_addr = htonl(t1address);
446 1 : addr::addr t1;
447 1 : t1.set_ipv4(t1in);
448 :
449 : // from is set to 10.2.0.0
450 1 : struct sockaddr_in f2in = sockaddr_in();
451 1 : f2in.sin_family = AF_INET;
452 1 : f2in.sin_port = htons(rand());
453 : uint32_t f2address((10 << 24)
454 : | (2 << 16)
455 : | (0 << 8)
456 1 : | 0);
457 1 : f2in.sin_addr.s_addr = htonl(f2address);
458 1 : addr::addr f2;
459 1 : f2.set_ipv4(f2in);
460 :
461 : // from is set to 10.10.255.255
462 1 : struct sockaddr_in t2in = sockaddr_in();
463 1 : t2in.sin_family = AF_INET;
464 1 : t2in.sin_port = htons(rand());
465 : uint32_t t2address((10 << 24)
466 : | (10 << 16)
467 : | (255 << 8)
468 1 : | 255);
469 1 : t2in.sin_addr.s_addr = htonl(t2address);
470 1 : addr::addr t2;
471 1 : t2.set_ipv4(t2in);
472 :
473 1 : addr::addr_range range1;
474 1 : range1.set_from(f1);
475 1 : range1.set_to(t1);
476 :
477 1 : addr::addr_range range2;
478 1 : range2.set_from(f2);
479 1 : range2.set_to(t2);
480 :
481 1 : CATCH_REQUIRE(range1.is_range());
482 1 : CATCH_REQUIRE_FALSE(range1.is_empty());
483 1 : CATCH_REQUIRE(range2.is_range());
484 1 : CATCH_REQUIRE_FALSE(range2.is_empty());
485 :
486 1 : addr::addr_range range3(range1.intersection(range2));
487 :
488 1 : CATCH_REQUIRE(range3.is_range());
489 1 : CATCH_REQUIRE_FALSE(range3.is_empty());
490 :
491 1 : CATCH_REQUIRE(range3.get_from().to_ipv4_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "10.2.0.0");
492 1 : CATCH_REQUIRE(range3.get_to().to_ipv4_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "10.5.255.255");
493 : }
494 :
495 4 : CATCH_SECTION("two ranges that do not overlap")
496 : {
497 : // from is set to 10.1.0.0
498 1 : struct sockaddr_in f1in = sockaddr_in();
499 1 : f1in.sin_family = AF_INET;
500 1 : f1in.sin_port = htons(rand());
501 : uint32_t f1address((10 << 24)
502 : | (1 << 16)
503 : | (0 << 8)
504 1 : | 0);
505 1 : f1in.sin_addr.s_addr = htonl(f1address);
506 1 : addr::addr f1;
507 1 : f1.set_ipv4(f1in);
508 :
509 : // from is set to 10.5.255.255
510 1 : struct sockaddr_in t1in = sockaddr_in();
511 1 : t1in.sin_family = AF_INET;
512 1 : t1in.sin_port = htons(rand());
513 : uint32_t t1address((10 << 24)
514 : | (5 << 16)
515 : | (255 << 8)
516 1 : | 255);
517 1 : t1in.sin_addr.s_addr = htonl(t1address);
518 1 : addr::addr t1;
519 1 : t1.set_ipv4(t1in);
520 :
521 : // from is set to 10.10.0.0
522 1 : struct sockaddr_in f2in = sockaddr_in();
523 1 : f2in.sin_family = AF_INET;
524 1 : f2in.sin_port = htons(rand());
525 : uint32_t f2address((10 << 24)
526 : | (10 << 16)
527 : | (0 << 8)
528 1 : | 0);
529 1 : f2in.sin_addr.s_addr = htonl(f2address);
530 1 : addr::addr f2;
531 1 : f2.set_ipv4(f2in);
532 :
533 : // from is set to 10.20.255.255
534 1 : struct sockaddr_in t2in = sockaddr_in();
535 1 : t2in.sin_family = AF_INET;
536 1 : t2in.sin_port = htons(rand());
537 : uint32_t t2address((10 << 24)
538 : | (20 << 16)
539 : | (255 << 8)
540 1 : | 255);
541 1 : t2in.sin_addr.s_addr = htonl(t2address);
542 1 : addr::addr t2;
543 1 : t2.set_ipv4(t2in);
544 :
545 1 : addr::addr_range range1;
546 1 : range1.set_from(f1);
547 1 : range1.set_to(t1);
548 :
549 1 : addr::addr_range range2;
550 1 : range2.set_from(f2);
551 1 : range2.set_to(t2);
552 :
553 1 : CATCH_REQUIRE(range1.is_range());
554 1 : CATCH_REQUIRE_FALSE(range1.is_empty());
555 1 : CATCH_REQUIRE(range2.is_range());
556 1 : CATCH_REQUIRE_FALSE(range2.is_empty());
557 :
558 1 : addr::addr_range range3(range1.intersection(range2));
559 :
560 1 : CATCH_REQUIRE(range3.is_range());
561 1 : CATCH_REQUIRE(range3.is_empty());
562 :
563 : // although it is "empty" we know the IPs and can test them
564 : //
565 1 : CATCH_REQUIRE(range3.get_from().to_ipv4_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "10.10.0.0");
566 1 : CATCH_REQUIRE(range3.get_to().to_ipv4_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "10.5.255.255");
567 :
568 2 : addr::addr_range::vector_t rlist;
569 1 : rlist.push_back(range1);
570 1 : rlist.push_back(range2);
571 1 : CATCH_REQUIRE(addr::address_match_ranges(rlist, f1));
572 1 : CATCH_REQUIRE(addr::address_match_ranges(rlist, f2));
573 1 : CATCH_REQUIRE(addr::address_match_ranges(rlist, t1));
574 1 : CATCH_REQUIRE(addr::address_match_ranges(rlist, t2));
575 : }
576 : }
577 11 : }
578 :
579 :
580 :
581 :
582 :
583 : // vim: ts=4 sw=4 et
|
