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.
- checksums.yaml +7 -0
- data/.byebug_history +25 -0
- data/.document +5 -0
- data/.gitignore +20 -0
- data/.rock.yml +5 -0
- data/.travis.yml +13 -0
- data/CHANGELOG.md +31 -0
- data/CHANGELOG.rdoc +115 -0
- data/CONTRIBUTING.md +39 -0
- data/Gemfile +5 -0
- data/LICENSE.txt +20 -0
- data/README.rdoc +964 -0
- data/Rakefile +69 -0
- data/VERSION +1 -0
- data/ipaddress_2.gemspec +30 -0
- data/lib/ipaddress_2/ipv4.rb +1204 -0
- data/lib/ipaddress_2/ipv6.rb +1274 -0
- data/lib/ipaddress_2/mongoid.rb +75 -0
- data/lib/ipaddress_2/prefix.rb +285 -0
- data/lib/ipaddress_2/version.rb +3 -0
- data/lib/ipaddress_2.rb +293 -0
- data/test/ipaddress_2/ipv4_test.rb +701 -0
- data/test/ipaddress_2/ipv6_test.rb +707 -0
- data/test/ipaddress_2/mongoid_test.rb +70 -0
- data/test/ipaddress_2/prefix_test.rb +171 -0
- data/test/ipaddress_2_test.rb +109 -0
- data/test/test_helper.rb +37 -0
- metadata +195 -0
@@ -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
|