ipaddress_2 0.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,701 @@
1
+ require 'test_helper'
2
+
3
+ class IPv4Test < Minitest::Test
4
+
5
+ def setup
6
+ @klass = IPAddress::IPv4
7
+
8
+ @valid_ipv4 = {
9
+ "0.0.0.0/0" => ["0.0.0.0", 0],
10
+ "10.0.0.0" => ["10.0.0.0", 32],
11
+ "10.0.0.1" => ["10.0.0.1", 32],
12
+ "10.0.0.1/24" => ["10.0.0.1", 24],
13
+ "10.0.0.1/255.255.255.0" => ["10.0.0.1", 24]}
14
+
15
+ @invalid_ipv4 = ["10.0.0.256",
16
+ "10.0.0.0.0",
17
+ "10.0.0",
18
+ "10.0"]
19
+
20
+ @valid_ipv4_range = ["10.0.0.1-254",
21
+ "10.0.1-254.0",
22
+ "10.1-254.0.0"]
23
+
24
+ @netmask_values = {
25
+ "0.0.0.0/0" => "0.0.0.0",
26
+ "10.0.0.0/8" => "255.0.0.0",
27
+ "172.16.0.0/16" => "255.255.0.0",
28
+ "192.168.0.0/24" => "255.255.255.0",
29
+ "192.168.100.4/30" => "255.255.255.252",
30
+ "192.168.12.4/32" => "255.255.255.255"}
31
+
32
+ @decimal_values ={
33
+ "0.0.0.0/0" => 0,
34
+ "10.0.0.0/8" => 167772160,
35
+ "172.16.0.0/16" => 2886729728,
36
+ "192.168.0.0/24" => 3232235520,
37
+ "192.168.100.4/30" => 3232261124}
38
+
39
+ @hex_values = {
40
+ "10.0.0.0" => "0a000000",
41
+ "172.16.5.4" => "ac100504",
42
+ "192.168.100.4" => "c0a86404",
43
+ }
44
+
45
+ @ip = @klass.new("172.16.10.1/24")
46
+ @network = @klass.new("172.16.10.0/24")
47
+
48
+ @broadcast = {
49
+ "10.0.0.0/8" => "10.255.255.255/8",
50
+ "172.16.0.0/16" => "172.16.255.255/16",
51
+ "192.168.0.0/24" => "192.168.0.255/24",
52
+ "192.168.100.4/30" => "192.168.100.7/30",
53
+ "192.168.12.3/31" => "255.255.255.255/31",
54
+ "10.0.0.1/32" => "10.0.0.1/32"}
55
+
56
+ @networks = {
57
+ "10.5.4.3/8" => "10.0.0.0/8",
58
+ "172.16.5.4/16" => "172.16.0.0/16",
59
+ "192.168.4.3/24" => "192.168.4.0/24",
60
+ "192.168.100.5/30" => "192.168.100.4/30",
61
+ "192.168.1.3/31" => "192.168.1.2/31",
62
+ "192.168.2.5/32" => "192.168.2.5/32"}
63
+
64
+ @class_a = @klass.new("10.0.0.1/8")
65
+ @class_b = @klass.new("172.16.0.1/16")
66
+ @class_c = @klass.new("192.168.0.1/24")
67
+
68
+ @classful = {
69
+ "10.1.1.1" => 8,
70
+ "150.1.1.1" => 16,
71
+ "200.1.1.1" => 24 }
72
+
73
+ @in_range = {
74
+ "10.32.0.1" => ["10.32.0.253", 253],
75
+ "192.0.0.0" => ["192.1.255.255", 131072]
76
+ }
77
+
78
+ @link_local = [
79
+ "169.254.0.0",
80
+ "169.254.255.255",
81
+ "169.254.12.34",
82
+ "169.254.0.0/16",
83
+ "169.254.0.0/17"]
84
+
85
+ @not_link_local = [
86
+ "127.0.0.1",
87
+ "127.0.1.1",
88
+ "192.168.0.100",
89
+ "169.255.0.0",
90
+ "169.254.0.0/15",
91
+ "0.0.0.0",
92
+ "255.255.255.255"]
93
+
94
+ end
95
+
96
+ def test_initialize
97
+ @valid_ipv4.keys.each do |i|
98
+ ip = @klass.new(i)
99
+ assert_instance_of @klass, ip
100
+ end
101
+ assert_instance_of IPAddress::Prefix32, @ip.prefix
102
+ assert_raises(ArgumentError) do
103
+ @klass.new
104
+ end
105
+ end
106
+
107
+ def test_initialize_format_error
108
+ @invalid_ipv4.each do |i|
109
+ assert_raises(ArgumentError) {@klass.new(i)}
110
+ end
111
+ assert_raises (ArgumentError) {@klass.new(nil)}
112
+ assert_raises (ArgumentError) {@klass.new("10.0.0.0/asd")}
113
+ end
114
+
115
+ def test_initialize_without_prefix
116
+ ip = @klass.new("10.10.0.0")
117
+ assert_instance_of IPAddress::Prefix32, ip.prefix
118
+ assert_equal 32, ip.prefix.to_i
119
+ end
120
+
121
+ def test_attributes
122
+ @valid_ipv4.each do |arg,attr|
123
+ ip = @klass.new(arg)
124
+ assert_equal attr.first, ip.address
125
+ assert_equal attr.last, ip.prefix.to_i
126
+ end
127
+ end
128
+
129
+ def test_octets
130
+ ip = @klass.new("10.1.2.3/8")
131
+ assert_equal ip.octets, [10,1,2,3]
132
+ end
133
+
134
+ def test_initialize_should_require_ip
135
+ assert_raises(ArgumentError) { @klass.new }
136
+ end
137
+
138
+ def test_method_as_json
139
+ ip = @klass.new("172.16.100.4/22")
140
+ assert_equal "172.16.100.4/22", ip.as_json
141
+ end
142
+
143
+ def test_method_data
144
+ if RUBY_VERSION < "2.0"
145
+ assert_equal "\254\020\n\001", @ip.data
146
+ else
147
+ assert_equal "\xAC\x10\n\x01".b, @ip.data
148
+ end
149
+ end
150
+
151
+ def test_method_to_string
152
+ @valid_ipv4.each do |arg,attr|
153
+ ip = @klass.new(arg)
154
+ assert_equal attr.join("/"), ip.to_string
155
+ end
156
+ end
157
+
158
+ def test_method_to_s
159
+ @valid_ipv4.each do |arg,attr|
160
+ ip = @klass.new(arg)
161
+ assert_equal attr.first, ip.to_s
162
+ end
163
+ end
164
+
165
+ def test_netmask
166
+ @netmask_values.each do |addr,mask|
167
+ ip = @klass.new(addr)
168
+ assert_equal mask, ip.netmask
169
+ end
170
+ end
171
+
172
+ def test_method_to_u32
173
+ @decimal_values.each do |addr,int|
174
+ ip = @klass.new(addr)
175
+ assert_equal int, ip.to_u32
176
+ end
177
+ end
178
+
179
+ def test_method_to_hex
180
+ @hex_values.each do |addr,hex|
181
+ ip = @klass.new(addr)
182
+ assert_equal hex, ip.to_hex
183
+ end
184
+ end
185
+
186
+ def test_method_network?
187
+ assert_equal true, @network.network?
188
+ assert_equal false, @ip.network?
189
+ end
190
+
191
+ def test_one_address_network
192
+ network = @klass.new("172.16.10.1/32")
193
+ assert_equal false, network.network?
194
+ end
195
+
196
+ def test_method_broadcast
197
+ @broadcast.each do |addr,bcast|
198
+ ip = @klass.new(addr)
199
+ assert_instance_of @klass, ip.broadcast
200
+ assert_equal bcast, ip.broadcast.to_string
201
+ end
202
+ end
203
+
204
+ def test_method_network
205
+ @networks.each do |addr,net|
206
+ ip = @klass.new addr
207
+ assert_instance_of @klass, ip.network
208
+ assert_equal net, ip.network.to_string
209
+ end
210
+ end
211
+
212
+ def test_method_bits
213
+ ip = @klass.new("127.0.0.1")
214
+ assert_equal "01111111000000000000000000000001", ip.bits
215
+ end
216
+
217
+ def test_method_first
218
+ ip = @klass.new("192.168.100.0/24")
219
+ assert_instance_of @klass, ip.first
220
+ assert_equal "192.168.100.1", ip.first.to_s
221
+ ip = @klass.new("192.168.100.50/24")
222
+ assert_instance_of @klass, ip.first
223
+ assert_equal "192.168.100.1", ip.first.to_s
224
+ ip = @klass.new("192.168.100.50/32")
225
+ assert_instance_of @klass, ip.first
226
+ assert_equal "192.168.100.50", ip.first.to_s
227
+ ip = @klass.new("192.168.100.50/31")
228
+ assert_instance_of @klass, ip.first
229
+ assert_equal "192.168.100.50", ip.first.to_s
230
+ end
231
+
232
+ def test_method_last
233
+ ip = @klass.new("192.168.100.0/24")
234
+ assert_instance_of @klass, ip.last
235
+ assert_equal "192.168.100.254", ip.last.to_s
236
+ ip = @klass.new("192.168.100.50/24")
237
+ assert_instance_of @klass, ip.last
238
+ assert_equal "192.168.100.254", ip.last.to_s
239
+ ip = @klass.new("192.168.100.50/32")
240
+ assert_instance_of @klass, ip.last
241
+ assert_equal "192.168.100.50", ip.last.to_s
242
+ ip = @klass.new("192.168.100.50/31")
243
+ assert_instance_of @klass, ip.last
244
+ assert_equal "192.168.100.51", ip.last.to_s
245
+ end
246
+
247
+ def test_method_each_host
248
+ ip = @klass.new("10.0.0.1/29")
249
+ arr = []
250
+ ip.each_host {|i| arr << i.to_s}
251
+ expected = ["10.0.0.1","10.0.0.2","10.0.0.3",
252
+ "10.0.0.4","10.0.0.5","10.0.0.6"]
253
+ assert_equal expected, arr
254
+ end
255
+
256
+ def test_method_each
257
+ ip = @klass.new("10.0.0.1/29")
258
+ arr = []
259
+ ip.each {|i| arr << i.to_s}
260
+ expected = ["10.0.0.0","10.0.0.1","10.0.0.2",
261
+ "10.0.0.3","10.0.0.4","10.0.0.5",
262
+ "10.0.0.6","10.0.0.7"]
263
+ assert_equal expected, arr
264
+ end
265
+
266
+ def test_method_succ
267
+ ip = @klass.new("192.168.100.0/24")
268
+ assert_instance_of @klass, ip.succ
269
+ assert_equal "192.168.100.1/24", ip.succ.to_string
270
+ ip = @klass.new("192.168.100.50/24")
271
+ assert_instance_of @klass, ip.succ
272
+ assert_equal "192.168.100.51/24", ip.succ.to_string
273
+ ip = @klass.new("0.0.0.0/32")
274
+ assert_instance_of @klass, ip.succ
275
+ assert_equal "0.0.0.1/32", ip.succ.to_string
276
+ ip = @klass.new("255.255.255.255/32")
277
+ assert_instance_of @klass, ip.succ
278
+ assert_equal "0.0.0.0/32", ip.succ.to_string
279
+ end
280
+
281
+ def test_method_pred
282
+ ip = @klass.new("192.168.100.0/24")
283
+ assert_instance_of @klass, ip.pred
284
+ assert_equal "192.168.99.255/24", ip.pred.to_string
285
+ ip = @klass.new("192.168.100.50/24")
286
+ assert_instance_of @klass, ip.pred
287
+ assert_equal "192.168.100.49/24", ip.pred.to_string
288
+ ip = @klass.new("0.0.0.0/32")
289
+ assert_instance_of @klass, ip.pred
290
+ assert_equal "255.255.255.255/32", ip.pred.to_string
291
+ ip = @klass.new("255.255.255.255/32")
292
+ assert_instance_of @klass, ip.pred
293
+ assert_equal "255.255.255.254/32", ip.pred.to_string
294
+ end
295
+
296
+ def test_method_size
297
+ ip = @klass.new("10.0.0.1/29")
298
+ assert_equal 8, ip.size
299
+ end
300
+
301
+ def test_method_hosts
302
+ ip = @klass.new("10.0.0.1/29")
303
+ expected = ["10.0.0.1","10.0.0.2","10.0.0.3",
304
+ "10.0.0.4","10.0.0.5","10.0.0.6"]
305
+ assert_equal expected, ip.hosts.map {|i| i.to_s}
306
+ end
307
+
308
+ def test_method_network_u32
309
+ assert_equal 2886732288, @ip.network_u32
310
+ end
311
+
312
+ def test_method_broadcast_u32
313
+ assert_equal 2886732543, @ip.broadcast_u32
314
+ end
315
+
316
+ def test_method_include?
317
+ ip = @klass.new("192.168.10.100/24")
318
+ addr = @klass.new("192.168.10.102/24")
319
+ assert_equal true, ip.include?(addr)
320
+ assert_equal false, ip.include?(@klass.new("172.16.0.48"))
321
+ ip = @klass.new("10.0.0.0/8")
322
+ assert_equal true, ip.include?(@klass.new("10.0.0.0/9"))
323
+ assert_equal true, ip.include?(@klass.new("10.1.1.1/32"))
324
+ assert_equal true, ip.include?(@klass.new("10.1.1.1/9"))
325
+ assert_equal false, ip.include?(@klass.new("172.16.0.0/16"))
326
+ assert_equal false, ip.include?(@klass.new("10.0.0.0/7"))
327
+ assert_equal false, ip.include?(@klass.new("5.5.5.5/32"))
328
+ assert_equal false, ip.include?(@klass.new("11.0.0.0/8"))
329
+ ip = @klass.new("13.13.0.0/13")
330
+ assert_equal false, ip.include?(@klass.new("13.16.0.0/32"))
331
+ end
332
+
333
+ def test_method_include_all?
334
+ ip = @klass.new("192.168.10.100/24")
335
+ addr1 = @klass.new("192.168.10.102/24")
336
+ addr2 = @klass.new("192.168.10.103/24")
337
+ assert_equal true, ip.include_all?(addr1,addr2)
338
+ assert_equal false, ip.include_all?(addr1, @klass.new("13.16.0.0/32"))
339
+ end
340
+
341
+ def test_method_ipv4?
342
+ assert_equal true, @ip.ipv4?
343
+ end
344
+
345
+ def test_method_ipv6?
346
+ assert_equal false, @ip.ipv6?
347
+ end
348
+
349
+ def test_method_private?
350
+ assert_equal true, @klass.new("192.168.10.50/24").private?
351
+ assert_equal true, @klass.new("192.168.10.50/16").private?
352
+ assert_equal true, @klass.new("172.16.77.40/24").private?
353
+ assert_equal true, @klass.new("172.16.10.50/14").private?
354
+ assert_equal true, @klass.new("10.10.10.10/10").private?
355
+ assert_equal true, @klass.new("10.0.0.0/8").private?
356
+ assert_equal false, @klass.new("192.168.10.50/12").private?
357
+ assert_equal false, @klass.new("3.3.3.3").private?
358
+ assert_equal false, @klass.new("10.0.0.0/7").private?
359
+ assert_equal false, @klass.new("172.32.0.0/12").private?
360
+ assert_equal false, @klass.new("172.16.0.0/11").private?
361
+ assert_equal false, @klass.new("192.0.0.2/24").private?
362
+ end
363
+
364
+ def test_method_link_local?
365
+ @link_local.each do |addr|
366
+ assert_equal true, @klass.new(addr).link_local?
367
+ end
368
+ @not_link_local.each do |addr|
369
+ assert_equal false, @klass.new(addr).link_local?
370
+ end
371
+ end
372
+
373
+ def test_method_octet
374
+ assert_equal 172, @ip[0]
375
+ assert_equal 16, @ip[1]
376
+ assert_equal 10, @ip[2]
377
+ assert_equal 1, @ip[3]
378
+ end
379
+
380
+ def test_method_a?
381
+ assert_equal true, @class_a.a?
382
+ assert_equal false, @class_b.a?
383
+ assert_equal false, @class_c.a?
384
+ end
385
+
386
+ def test_method_b?
387
+ assert_equal true, @class_b.b?
388
+ assert_equal false, @class_a.b?
389
+ assert_equal false, @class_c.b?
390
+ end
391
+
392
+ def test_method_c?
393
+ assert_equal true, @class_c.c?
394
+ assert_equal false, @class_a.c?
395
+ assert_equal false, @class_b.c?
396
+ end
397
+
398
+ def test_method_to_ipv6
399
+ assert_equal "ac10:0a01", @ip.to_ipv6
400
+ end
401
+
402
+ def test_method_reverse
403
+ assert_equal "1.10.16.172.in-addr.arpa", @ip.reverse
404
+ end
405
+
406
+ def test_method_compare
407
+ ip1 = @klass.new("10.1.1.1/8")
408
+ ip2 = @klass.new("10.1.1.1/16")
409
+ ip3 = @klass.new("172.16.1.1/14")
410
+ ip4 = @klass.new("10.1.1.1/8")
411
+
412
+ # ip2 should be greater than ip1
413
+ assert_equal true, ip1 < ip2
414
+ assert_equal false, ip1 > ip2
415
+ assert_equal false, ip2 < ip1
416
+ # ip2 should be less than ip3
417
+ assert_equal true, ip2 < ip3
418
+ assert_equal false, ip2 > ip3
419
+ # ip1 should be less than ip3
420
+ assert_equal true, ip1 < ip3
421
+ assert_equal false, ip1 > ip3
422
+ assert_equal false, ip3 < ip1
423
+ # ip1 should be equal to itself
424
+ assert_equal true, ip1 == ip1
425
+ # ip1 should be equal to ip4
426
+ assert_equal true, ip1 == ip4
427
+ # test sorting
428
+ arr = ["10.1.1.1/8","10.1.1.1/16","172.16.1.1/14"]
429
+ assert_equal arr, [ip1,ip2,ip3].sort.map{|s| s.to_string}
430
+ # test same prefix
431
+ ip1 = @klass.new("10.0.0.0/24")
432
+ ip2 = @klass.new("10.0.0.0/16")
433
+ ip3 = @klass.new("10.0.0.0/8")
434
+ arr = ["10.0.0.0/8","10.0.0.0/16","10.0.0.0/24"]
435
+ assert_equal arr, [ip1,ip2,ip3].sort.map{|s| s.to_string}
436
+ # compare with alien thing
437
+ ip1 = @klass.new('127.0.0.1')
438
+ ip2 = IPAddress::IPv6.new('::1')
439
+ not_ip = String
440
+ assert_nil ip1 <=> ip2
441
+ assert_nil ip1 <=> not_ip
442
+ end
443
+
444
+ def test_method_minus
445
+ ip1 = @klass.new("10.1.1.1/8")
446
+ ip2 = @klass.new("10.1.1.10/8")
447
+ assert_equal 9, ip2 - ip1
448
+ assert_equal 9, ip1 - ip2
449
+ end
450
+
451
+ def test_method_plus
452
+ ip1 = @klass.new("172.16.10.1/24")
453
+ ip2 = @klass.new("172.16.11.2/24")
454
+ assert_equal ["172.16.10.0/23"], (ip1+ip2).map{|i| i.to_string}
455
+
456
+ ip2 = @klass.new("172.16.12.2/24")
457
+ assert_equal [ip1.network.to_string, ip2.network.to_string],
458
+ (ip1 + ip2).map{|i| i.to_string}
459
+
460
+ ip1 = @klass.new("10.0.0.0/23")
461
+ ip2 = @klass.new("10.0.2.0/24")
462
+ assert_equal ["10.0.0.0/23","10.0.2.0/24"], (ip1+ip2).map{|i| i.to_string}
463
+
464
+ ip1 = @klass.new("10.0.0.0/23")
465
+ ip2 = @klass.new("10.0.2.0/24")
466
+ assert_equal ["10.0.0.0/23","10.0.2.0/24"], (ip2+ip1).map{|i| i.to_string}
467
+
468
+ ip1 = @klass.new("10.0.0.0/16")
469
+ ip2 = @klass.new("10.0.2.0/24")
470
+ assert_equal ["10.0.0.0/16"], (ip1+ip2).map{|i| i.to_string}
471
+
472
+ ip1 = @klass.new("10.0.0.0/23")
473
+ ip2 = @klass.new("10.1.0.0/24")
474
+ assert_equal ["10.0.0.0/23","10.1.0.0/24"], (ip1+ip2).map{|i| i.to_string}
475
+
476
+ end
477
+
478
+ def test_method_netmask_equal
479
+ ip = @klass.new("10.1.1.1/16")
480
+ assert_equal 16, ip.prefix.to_i
481
+ ip.netmask = "255.255.255.0"
482
+ assert_equal 24, ip.prefix.to_i
483
+ end
484
+
485
+ def test_method_split
486
+ assert_raises(ArgumentError) {@ip.split(0)}
487
+ assert_raises(ArgumentError) {@ip.split(257)}
488
+
489
+ assert_equal @ip.network, @ip.split(1).first
490
+
491
+ arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27",
492
+ "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27",
493
+ "172.16.10.192/27", "172.16.10.224/27"]
494
+ assert_equal arr, @network.split(8).map {|s| s.to_string}
495
+ arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27",
496
+ "172.16.10.96/27", "172.16.10.128/27", "172.16.10.160/27",
497
+ "172.16.10.192/26"]
498
+ assert_equal arr, @network.split(7).map {|s| s.to_string}
499
+ arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27",
500
+ "172.16.10.96/27", "172.16.10.128/26", "172.16.10.192/26"]
501
+ assert_equal arr, @network.split(6).map {|s| s.to_string}
502
+ arr = ["172.16.10.0/27", "172.16.10.32/27", "172.16.10.64/27",
503
+ "172.16.10.96/27", "172.16.10.128/25"]
504
+ assert_equal arr, @network.split(5).map {|s| s.to_string}
505
+ arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26",
506
+ "172.16.10.192/26"]
507
+ assert_equal arr, @network.split(4).map {|s| s.to_string}
508
+ arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/25"]
509
+ assert_equal arr, @network.split(3).map {|s| s.to_string}
510
+ arr = ["172.16.10.0/25", "172.16.10.128/25"]
511
+ assert_equal arr, @network.split(2).map {|s| s.to_string}
512
+ arr = ["172.16.10.0/24"]
513
+ assert_equal arr, @network.split(1).map {|s| s.to_string}
514
+ end
515
+
516
+ def test_method_subnet
517
+ assert_raises(ArgumentError) {@network.subnet(23)}
518
+ assert_raises(ArgumentError) {@network.subnet(33)}
519
+ arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26",
520
+ "172.16.10.192/26"]
521
+ assert_equal arr, @network.subnet(26).map {|s| s.to_string}
522
+ arr = ["172.16.10.0/25", "172.16.10.128/25"]
523
+ assert_equal arr, @network.subnet(25).map {|s| s.to_string}
524
+ arr = ["172.16.10.0/24"]
525
+ assert_equal arr, @network.subnet(24).map {|s| s.to_string}
526
+ end
527
+
528
+ def test_method_supernet
529
+ assert_raises(ArgumentError) {@ip.supernet(24)}
530
+ assert_equal "0.0.0.0/0", @ip.supernet(0).to_string
531
+ assert_equal "0.0.0.0/0", @ip.supernet(-2).to_string
532
+ assert_equal "172.16.10.0/23", @ip.supernet(23).to_string
533
+ assert_equal "172.16.8.0/22", @ip.supernet(22).to_string
534
+ end
535
+
536
+ def test_classmethod_parse_u32
537
+ @decimal_values.each do |addr,int|
538
+ ip = @klass.parse_u32(int)
539
+ ip.prefix = addr.split("/").last.to_i
540
+ assert_equal ip.to_string, addr
541
+ end
542
+ end
543
+
544
+ def test_classhmethod_extract
545
+ str = "foobar172.16.10.1barbaz"
546
+ assert_equal "172.16.10.1", @klass.extract(str).to_s
547
+ end
548
+
549
+ def test_classmethod_summarize
550
+
551
+ # Should return self if only one network given
552
+ assert_equal [@ip.network], @klass.summarize(@ip)
553
+
554
+ # Summarize homogeneous networks
555
+ ip1 = @klass.new("172.16.10.1/24")
556
+ ip2 = @klass.new("172.16.11.2/24")
557
+ assert_equal ["172.16.10.0/23"], @klass.summarize(ip1,ip2).map{|i| i.to_string}
558
+
559
+ ip1 = @klass.new("10.0.0.1/24")
560
+ ip2 = @klass.new("10.0.1.1/24")
561
+ ip3 = @klass.new("10.0.2.1/24")
562
+ ip4 = @klass.new("10.0.3.1/24")
563
+ assert_equal ["10.0.0.0/22"], @klass.summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
564
+ assert_equal ["10.0.0.0/22"], @klass.summarize(ip4,ip3,ip2,ip1).map{|i| i.to_string}
565
+
566
+ # Summarize non homogeneous networks
567
+ ip1 = @klass.new("10.0.0.0/23")
568
+ ip2 = @klass.new("10.0.2.0/24")
569
+ assert_equal ["10.0.0.0/23","10.0.2.0/24"], @klass.summarize(ip1,ip2).map{|i| i.to_string}
570
+
571
+ ip1 = @klass.new("10.0.0.0/16")
572
+ ip2 = @klass.new("10.0.2.0/24")
573
+ assert_equal ["10.0.0.0/16"], @klass.summarize(ip1,ip2).map{|i| i.to_string}
574
+
575
+ ip1 = @klass.new("10.0.0.0/23")
576
+ ip2 = @klass.new("10.1.0.0/24")
577
+ assert_equal ["10.0.0.0/23","10.1.0.0/24"], @klass.summarize(ip1,ip2).map{|i| i.to_string}
578
+
579
+ ip1 = @klass.new("10.0.0.0/23")
580
+ ip2 = @klass.new("10.0.2.0/23")
581
+ ip3 = @klass.new("10.0.4.0/24")
582
+ ip4 = @klass.new("10.0.6.0/24")
583
+ assert_equal ["10.0.0.0/22","10.0.4.0/24","10.0.6.0/24"],
584
+ @klass.summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
585
+
586
+ ip1 = @klass.new("10.0.1.1/24")
587
+ ip2 = @klass.new("10.0.2.1/24")
588
+ ip3 = @klass.new("10.0.3.1/24")
589
+ ip4 = @klass.new("10.0.4.1/24")
590
+ result = ["10.0.1.0/24","10.0.2.0/23","10.0.4.0/24"]
591
+ assert_equal result, @klass.summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
592
+ assert_equal result, @klass.summarize(ip4,ip3,ip2,ip1).map{|i| i.to_string}
593
+
594
+ ip1 = @klass.new("10.0.1.1/24")
595
+ ip2 = @klass.new("10.10.2.1/24")
596
+ ip3 = @klass.new("172.16.0.1/24")
597
+ ip4 = @klass.new("172.16.1.1/24")
598
+ result = ["10.0.1.0/24","10.10.2.0/24","172.16.0.0/23"]
599
+ assert_equal result, @klass.summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
600
+
601
+ ips = [@klass.new("10.0.0.12/30"),
602
+ @klass.new("10.0.100.0/24")]
603
+ result = ["10.0.0.12/30", "10.0.100.0/24"]
604
+ assert_equal result, @klass.summarize(*ips).map{|i| i.to_string}
605
+
606
+ ips = [@klass.new("172.16.0.0/31"),
607
+ @klass.new("10.10.2.1/32")]
608
+ result = ["10.10.2.1/32", "172.16.0.0/31"]
609
+ assert_equal result, @klass.summarize(*ips).map{|i| i.to_string}
610
+
611
+ ips = [@klass.new("172.16.0.0/32"),
612
+ @klass.new("10.10.2.1/32")]
613
+ result = ["10.10.2.1/32", "172.16.0.0/32"]
614
+ assert_equal result, @klass.summarize(*ips).map{|i| i.to_string}
615
+
616
+ end
617
+
618
+ def test_classmethod_parse_data
619
+ ip = @klass.parse_data "\254\020\n\001"
620
+ assert_instance_of @klass, ip
621
+ assert_equal "172.16.10.1", ip.address
622
+ assert_equal "172.16.10.1/32", ip.to_string
623
+ end
624
+
625
+ def test_classmethod_parse_classful
626
+ @classful.each do |ip,prefix|
627
+ res = @klass.parse_classful(ip)
628
+ assert_equal prefix, res.prefix
629
+ assert_equal "#{ip}/#{prefix}", res.to_string
630
+ end
631
+ assert_raises(ArgumentError){ @klass.parse_classful("192.168.256.257") }
632
+ end
633
+
634
+ def test_network_split
635
+ @classful.each do |ip,net|
636
+ x = @klass.new("#{ip}/#{net}")
637
+ assert_equal x.split(1).length, 1
638
+ assert_equal x.split(2).length, 2
639
+ assert_equal x.split(32).length, 32
640
+ assert_equal x.split(256).length, 256
641
+ end
642
+ end
643
+
644
+ def test_in_range
645
+ @in_range.each do |s,d|
646
+ ip = @klass.new(s)
647
+ assert_equal ip.to(d[0]).length, d[1]
648
+ end
649
+ end
650
+
651
+ def test_octect_updates
652
+ ip = @klass.new("10.0.1.15/32")
653
+ ip[1] = 15
654
+ assert_equal "10.15.1.15/32", ip.to_string
655
+
656
+ ip = @klass.new("172.16.100.1")
657
+ ip[3] = 200
658
+ assert_equal "172.16.100.200/32", ip.to_string
659
+
660
+ ip = @klass.new("192.168.199.0/24")
661
+ ip[2] = 200
662
+ assert_equal "192.168.200.0/24", ip.to_string
663
+ end
664
+
665
+ def test_allocate_addresses
666
+ ip = @klass.new("10.0.0.0/24")
667
+ ip1 = ip.allocate
668
+ ip2 = ip.allocate
669
+ ip3 = ip.allocate
670
+ assert_equal "10.0.0.1/24", ip1.to_string
671
+ assert_equal "10.0.0.2/24", ip2.to_string
672
+ assert_equal "10.0.0.3/24", ip3.to_string
673
+ end
674
+
675
+ def test_allocate_can_skip_addresses
676
+ ip = @klass.new("10.0.0.0/24")
677
+ ip1 = ip.allocate(2)
678
+ assert_equal "10.0.0.3/24", ip1.to_string
679
+ end
680
+
681
+ def test_allocate_will_raise_stopiteration
682
+ ip = @klass.new("10.0.0.0/30")
683
+ ip.allocate(3)
684
+ assert_raises (StopIteration) do
685
+ ip.allocate
686
+ end
687
+ end
688
+
689
+ def test_finds_adjacent_subnet
690
+ ip = @klass.new("10.0.0.0/24")
691
+ assert_equal "10.0.1.0/24", ip.find_adjacent_subnet
692
+ refute @klass.new("10.0.0.0/0").find_adjacent_subnet
693
+ assert_equal "10.0.0.0/8", @klass.new("11.0.0.0/8").find_adjacent_subnet
694
+ assert_equal "172.16.0.0/16", @klass.new("172.17.0.0/16").find_adjacent_subnet
695
+ assert_equal "192.168.4.0/24", @klass.new("192.168.5.0/24").find_adjacent_subnet
696
+ assert_equal "192.168.100.4/30", @klass.new("192.168.100.0/30").find_adjacent_subnet
697
+ assert_equal "192.168.1.2/31", @klass.new("192.168.1.0/31").find_adjacent_subnet
698
+ assert_equal "192.168.2.5/32", @klass.new("192.168.2.4/32").find_adjacent_subnet
699
+ end
700
+
701
+ end # class IPv4Test