ipadmin 0.1.3.1 → 0.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. data/README +199 -215
  2. data/lib/ip_admin.rb +1916 -2302
  3. data/tests/cidr_test.rb +162 -38
  4. data/tests/functions_test.rb +117 -53
  5. data/tests/tree_test.rb +39 -24
  6. metadata +2 -3
  7. data/tests/ipaddr_test.rb +0 -56
data/tests/cidr_test.rb CHANGED
@@ -10,37 +10,175 @@ class TestCIDR < Test::Unit::TestCase
10
10
  def test_new
11
11
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24') )
12
12
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => '192.168.1.0', :Netmask => '255.255.255.0') )
13
+ assert_not_nil(IPAdmin::CIDR.new(:CIDR => '192.168.1.1') )
13
14
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::/64') )
14
- assert_raise(RuntimeError){ IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24') }
15
- assert_raise(RuntimeError){ IPAdmin::CIDR.new(:CIDR => '192.168.1.0') }
16
- assert_raise(RuntimeError){ IPAdmin::CIDR.new(:CIDR => 'fec0::1/64') }
15
+ assert_not_nil(IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24') )
16
+ assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::1/64') )
17
17
  end
18
18
 
19
- def test_simple_methods
20
- ip4 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.1')
21
- ip6 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::1')
19
+ def test_contains
20
+
22
21
  cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
23
22
  cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26')
23
+ cidr4_3 = IPAdmin::CIDR.new(:CIDR => '192.168.2.0/26')
24
24
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
25
25
  cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::/96')
26
+ cidr6_3 = IPAdmin::CIDR.new(:CIDR => 'fe80::/96')
26
27
 
27
- assert_equal(1,cidr4.contains(ip4) )
28
- assert_equal(1,cidr6.contains(ip6) )
29
28
  assert_equal(1,cidr4.contains(cidr4_2) )
30
29
  assert_equal(1,cidr6.contains(cidr6_2) )
30
+ assert_nil(cidr4.contains(cidr4_3) )
31
+ assert_nil(cidr6.contains(cidr6_3) )
32
+ end
33
+
34
+ def test_nth
35
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
36
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/126')
31
37
 
32
- assert_equal('192.168.1.255',cidr4.last() )
38
+ assert_equal('192.168.1.1',cidr4.nth(:Index => 1) )
39
+ assert_kind_of(IPAdmin::CIDR,cidr4.nth(:Index => 1, :Objectify => 1) )
40
+ assert_raise(RuntimeError){ cidr4.nth(:Index => 256) }
41
+ assert_raise(ArgumentError){ cidr4.nth() }
42
+
43
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.nth(:Index => 1) )
44
+ assert_equal('fec0::1',cidr6.nth(:Index => 1, :Short => 1) )
45
+ assert_raise(RuntimeError){ cidr6.nth(:Index => 10) }
46
+ end
47
+
48
+ def test_enumerate
49
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
50
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
51
+
52
+ assert_equal(['192.168.1.0'],cidr4.enumerate(:Limit => 1) )
53
+ assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0000'],cidr6.enumerate(:Limit => 1) )
54
+ assert_equal(['fec0::'],cidr6.enumerate(:Limit => 1, :Short => 1) )
55
+
56
+
57
+ enums4 = cidr4.enumerate(:Limit => 2, :Bitstep => 5)
58
+ enums6 = cidr6.enumerate(:Limit => 2, :Bitstep => 5)
59
+ assert_equal('192.168.1.5', enums4[1] )
60
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0005', enums6[1] )
61
+
62
+ enums4 = cidr4.enumerate(:Objectify => 1,:Limit => 1)
63
+ assert_kind_of(IPAdmin::CIDR, enums4[0] )
64
+
65
+ end
66
+
67
+ def test_next_ip
68
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
69
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
70
+
71
+ next4 = cidr4.next_ip()
72
+ next6 = cidr6.next_ip()
73
+ assert_equal('192.168.2.0',next4 )
74
+ assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000',next6 )
75
+
76
+ next6 = cidr6.next_ip(:Short => 1)
77
+ assert_equal('fec0:0:0:1::',next6 )
78
+
79
+ next4 = cidr4.next_ip(:Bitstep => 2)
80
+ next6 = cidr6.next_ip(:Bitstep => 2)
81
+ assert_equal('192.168.2.1',next4 )
82
+ assert_equal('fec0:0000:0000:0001:0000:0000:0000:0001',next6 )
83
+
84
+ next4 = cidr4.next_ip(:Objectify => 1)
85
+ next6 = cidr6.next_ip(:Objectify => 1)
86
+ assert_equal('192.168.2.0/32',next4.desc )
87
+ assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/128',next6.desc )
88
+
89
+ end
90
+
91
+ def test_next_subnet
92
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
93
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
94
+
95
+ next4 = cidr4.next_subnet()
96
+ next6 = cidr6.next_subnet()
97
+ assert_equal('192.168.2.0/24',next4 )
98
+ assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/64',next6 )
99
+
100
+ next6 = cidr6.next_subnet(:Short => 1)
101
+ assert_equal('fec0:0:0:1::/64',next6 )
102
+
103
+ next4 = cidr4.next_subnet(:Bitstep => 2)
104
+ next6 = cidr6.next_subnet(:Bitstep => 2)
105
+ assert_equal('192.168.3.0/24',next4 )
106
+ assert_equal('fec0:0000:0000:0002:0000:0000:0000:0000/64',next6 )
107
+
108
+ next4 = cidr4.next_subnet(:Objectify => 1)
109
+ next6 = cidr6.next_subnet(:Objectify => 1)
110
+ assert_equal('192.168.2.0/24',next4.desc )
111
+ assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/64',next6.desc )
112
+
113
+ end
114
+
115
+ def test_range
116
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
117
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
118
+
119
+ range4 = cidr4.range(:Indexes => [25,0], :Bitstep => 5)
120
+ range6 = cidr6.range(:Indexes => [25,0], :Bitstep => 5, :Short => 1)
33
121
 
122
+ assert_equal(6,range4.length)
123
+ assert_equal(6,range6.length)
124
+ assert_equal('192.168.1.0',range4[0])
125
+ assert_equal('192.168.1.25',range4[5])
126
+ assert_equal('fec0::',range6[0])
127
+ assert_equal('fec0::19',range6[5])
128
+ end
129
+
130
+ def test_remainder
131
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
132
+ cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.64/26')
133
+ remainder = cidr4.remainder(:Exclude => cidr4_2)
134
+
135
+ assert_equal(2,remainder.length)
136
+ assert_equal('192.168.1.0/26',remainder[0])
137
+
138
+ remainder = cidr4.remainder(:Exclude => cidr4_2, :Objectify => 1)
139
+ assert_equal('192.168.1.128/25',remainder[1].desc)
140
+ end
141
+
142
+ def test_resize
143
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.129/24')
144
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::1/64')
145
+
146
+ new4 = cidr4.resize(:Subnet => 23)
147
+ new6 = cidr6.resize(:Subnet => 63)
148
+ assert_equal('192.168.0.0/23',new4.desc )
149
+ assert_equal('fec0::/63',new6.desc(:Short => 1) )
150
+
151
+ cidr4.resize!(:Subnet => 25)
152
+ cidr6.resize!(:Subnet => 67)
153
+ assert_equal('192.168.1.0/25',cidr4.desc )
154
+ assert_equal('192.168.1.0',cidr4.ip )
155
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/67',cidr6.desc )
156
+ end
157
+
158
+ def test_simple_methods
159
+ cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24')
160
+ cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26')
161
+ cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::1/64')
162
+ cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::/96')
163
+
34
164
  assert_equal('192.168.1.0/24',cidr4.desc() )
35
165
  assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/64',cidr6.desc() )
36
166
 
37
- assert_equal('fec0::/64',cidr6.desc_short() )
167
+ assert_equal('fec0::/64',cidr6.desc(:Short => 1) )
38
168
 
39
169
  assert_equal('0.0.0.255',cidr4.hostmask_ext() )
40
170
 
41
171
  assert_equal(24,cidr4.bits() )
42
172
  assert_equal(64,cidr6.bits() )
43
173
 
174
+ assert_equal('192.168.1.1',cidr4.ip() )
175
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.ip() )
176
+ assert_equal('fec0::1',cidr6.ip(:Short => 1) )
177
+
178
+ assert_equal('192.168.1.255',cidr4.last() )
179
+ assert_equal('fec0:0000:0000:0000:ffff:ffff:ffff:ffff',cidr6.last() )
180
+ assert_equal('fec0::ffff:ffff:ffff:ffff',cidr6.last(:Short => 1) )
181
+
44
182
  assert_equal('/24',cidr4.netmask() )
45
183
  assert_equal('/64',cidr6.netmask() )
46
184
 
@@ -48,48 +186,27 @@ class TestCIDR < Test::Unit::TestCase
48
186
 
49
187
  assert_equal('192.168.1.0',cidr4.network() )
50
188
  assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000',cidr6.network() )
51
-
52
- assert_equal('192.168.1.1',cidr4.nth(:Index => 1) )
53
- assert_kind_of(IPAdmin::IPAddr,cidr4.nth(:Index => 1, :Objectify => 1) )
54
- assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.nth(:Index => 1) )
189
+ assert_equal('fec0::',cidr6.network(:Short => 1) )
55
190
 
56
191
  assert_equal(256,cidr4.size() )
57
192
  assert_equal(2**64,cidr6.size() )
58
193
  end
59
194
 
60
- def test_enumerate
61
- cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
62
- cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
63
-
64
- assert_equal(['192.168.1.0'],cidr4.enumerate(:Limit => 1) )
65
- assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0000'],cidr6.enumerate(:Limit => 1) )
66
-
67
-
68
- enums4 = cidr4.enumerate(:Limit => 2, :Bitstep => 5)
69
- enums6 = cidr6.enumerate(:Limit => 2, :Bitstep => 5)
70
- assert_equal('192.168.1.5', enums4[1] )
71
- assert_equal('fec0:0000:0000:0000:0000:0000:0000:0005', enums6[1] )
72
-
73
- enums4 = cidr4.enumerate(:Objectify => 1,:Limit => 1)
74
- assert_kind_of(IPAdmin::IPAddr, enums4[0] )
75
-
76
- end
77
-
78
195
  def test_subnet
79
196
  cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
80
197
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
81
198
 
82
199
  subnet4 = cidr4.subnet(:Subnet => 26, :MinCount => 4)
83
200
  subnet6 = cidr6.subnet(:Subnet => 66, :MinCount => 4)
84
- assert_equal('192.168.1.0/26', subnet4[0].desc)
85
- assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/66', subnet6[0].desc)
201
+ assert_equal('192.168.1.0/26', subnet4[0])
202
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/66', subnet6[0])
86
203
 
87
204
  subnet4 = cidr4.subnet(:Subnet => 26, :MinCount => 1)
88
- assert_equal('192.168.1.0/26', subnet4[0].desc)
89
- assert_equal('192.168.1.64/26', subnet4[1].desc)
90
- assert_equal('192.168.1.128/25', subnet4[2].desc)
205
+ assert_equal('192.168.1.0/26', subnet4[0])
206
+ assert_equal('192.168.1.64/26', subnet4[1])
207
+ assert_equal('192.168.1.128/25', subnet4[2])
91
208
 
92
- subnet4 = cidr4.subnet(:Subnet => 28, :MinCount => 3)
209
+ subnet4 = cidr4.subnet(:Subnet => 28, :MinCount => 3, :Objectify => 1)
93
210
  assert_equal('192.168.1.0/28', subnet4[0].desc)
94
211
  assert_equal('192.168.1.16/28', subnet4[1].desc)
95
212
  assert_equal('192.168.1.32/28', subnet4[2].desc)
@@ -97,6 +214,13 @@ class TestCIDR < Test::Unit::TestCase
97
214
  assert_equal('192.168.1.64/26', subnet4[4].desc)
98
215
  assert_equal('192.168.1.128/25', subnet4[5].desc)
99
216
 
217
+ subnet4 = cidr4.subnet(:IPCount => 112)
218
+ assert_equal('192.168.1.0/25', subnet4[0])
219
+
220
+ subnet4 = cidr4.subnet(:IPCount => 31)
221
+ assert_equal('192.168.1.0/27', subnet4[0])
222
+
223
+
100
224
  end
101
225
 
102
226
 
data/tests/functions_test.rb CHANGED
@@ -13,10 +13,10 @@ class TestFunct < Test::Unit::TestCase
13
13
 
14
14
 
15
15
  def test_pack_ipv4_netmask
16
- assert_equal([2**32-1,0], IPAdmin.pack_ipv4_netmask('255.255.255.255') )
17
- assert_equal([2**32-1,0], IPAdmin.pack_ipv4_netmask('32') )
18
- assert_equal([2**32-1,0], IPAdmin.pack_ipv4_netmask('/32') )
19
- assert_equal([2**32-1,0], IPAdmin.pack_ipv4_netmask(32) )
16
+ assert_equal(2**32-1, IPAdmin.pack_ipv4_netmask('255.255.255.255') )
17
+ assert_equal(2**32-1, IPAdmin.pack_ipv4_netmask('32') )
18
+ assert_equal(2**32-1, IPAdmin.pack_ipv4_netmask('/32') )
19
+ assert_equal(2**32-1, IPAdmin.pack_ipv4_netmask(32) )
20
20
  end
21
21
 
22
22
 
@@ -27,9 +27,9 @@ class TestFunct < Test::Unit::TestCase
27
27
 
28
28
 
29
29
  def test_pack_ipv6_netmask
30
- assert_equal([2**128-1,0], IPAdmin.pack_ipv6_netmask('128') )
31
- assert_equal([2**128-1,0], IPAdmin.pack_ipv6_netmask('/128') )
32
- assert_equal([2**128-1,0], IPAdmin.pack_ipv6_netmask(128) )
30
+ assert_equal(2**128-1, IPAdmin.pack_ipv6_netmask('128') )
31
+ assert_equal(2**128-1, IPAdmin.pack_ipv6_netmask('/128') )
32
+ assert_equal(2**128-1, IPAdmin.pack_ipv6_netmask(128) )
33
33
  end
34
34
 
35
35
 
@@ -54,71 +54,71 @@ class TestFunct < Test::Unit::TestCase
54
54
 
55
55
 
56
56
  def test_validate_ipv4_addr
57
- assert_equal(1, IPAdmin.validate_ipv4_addr('192.168.1.0') )
58
- assert_equal(1, IPAdmin.validate_ipv4_addr('255.255.255.255') )
57
+ assert_not_nil(IPAdmin.validate_ipv4_addr('192.168.1.0') )
58
+ assert_not_nil(IPAdmin.validate_ipv4_addr('255.255.255.255') )
59
+ assert_not_nil(IPAdmin.validate_ipv4_addr('224.0.0.1') )
59
60
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1.256') }
60
61
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192..168.1.1') }
61
62
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('0.168.1.1') }
62
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1z.255') }
63
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1a.255') }
63
64
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1.1.1') }
64
65
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('ffff::1111:1111') }
66
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('ff.ff.ff.ff') }
65
67
  end
66
68
 
67
69
 
68
70
  def test_validate_ipv4_netmask
69
- assert_equal(1, IPAdmin.validate_ipv4_netmask('255.255.255.0') )
70
- assert_equal(1, IPAdmin.validate_ipv4_netmask('128.0.0.0') )
71
- assert_equal(1, IPAdmin.validate_ipv4_netmask('32') )
72
- assert_equal(1, IPAdmin.validate_ipv4_netmask('/32') )
73
- assert_equal(1, IPAdmin.validate_ipv4_netmask(32) )
74
- assert_equal(1, IPAdmin.validate_ipv4_netmask('1') )
71
+ assert_not_nil(IPAdmin.validate_ipv4_netmask('255.255.255.0') )
72
+ assert_not_nil(IPAdmin.validate_ipv4_netmask('128.0.0.0') )
73
+ assert_not_nil(IPAdmin.validate_ipv4_netmask('32') )
74
+ assert_not_nil(IPAdmin.validate_ipv4_netmask('/32') )
75
+ assert_not_nil(IPAdmin.validate_ipv4_netmask(32) )
76
+ assert_not_nil(IPAdmin.validate_ipv4_netmask('1') )
75
77
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('192.255.255.0') }
76
78
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('255.255.255.194') }
77
79
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('256.255.255.0') }
78
80
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('0') }
79
81
  assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('33') }
80
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('32z') }
82
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('3a') }
83
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('ff.ff.ff.ff') }
81
84
  end
82
85
 
83
86
 
84
87
  def test_validate_ipv6_addr
85
- assert_equal(1, IPAdmin.validate_ipv6_addr('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
86
- assert_equal(1, IPAdmin.validate_ipv6_addr('ffff::1') )
87
- assert_equal(1, IPAdmin.validate_ipv6_addr('1234:5678:9abc:def0:1234:5678:9abc:def0') )
88
- assert_equal(1, IPAdmin.validate_ipv6_addr('::1') )
89
- assert_equal(1, IPAdmin.validate_ipv6_addr('ffff::') )
90
- assert_equal(1, IPAdmin.validate_ipv6_addr('0001::1') )
88
+ assert_not_nil(IPAdmin.validate_ipv6_addr('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
89
+ assert_not_nil(IPAdmin.validate_ipv6_addr('ffff::1') )
90
+ assert_not_nil(IPAdmin.validate_ipv6_addr('1234:5678:9abc:def0:1234:5678:9abc:def0') )
91
+ assert_not_nil(IPAdmin.validate_ipv6_addr('::1') )
92
+ assert_not_nil(IPAdmin.validate_ipv6_addr('ffff::') )
93
+ assert_not_nil(IPAdmin.validate_ipv6_addr('0001::1') )
91
94
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('ffff::1111::1111') }
92
95
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('abcd:efgh::1') }
93
96
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('fffff::1') }
94
97
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr(':::1') }
98
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('1:0:0:0:0:0:0:0:1') }
95
99
  end
96
100
 
97
101
 
98
102
  def test_validate_ipv6_netmask
99
- assert_equal(1, IPAdmin.validate_ipv6_netmask('1') )
100
- assert_equal(1, IPAdmin.validate_ipv6_netmask('128') )
101
- assert_equal(1, IPAdmin.validate_ipv6_netmask('/128') )
102
- assert_equal(1, IPAdmin.validate_ipv6_netmask(128) )
103
+ assert_not_nil(IPAdmin.validate_ipv6_netmask('1') )
104
+ assert_not_nil(IPAdmin.validate_ipv6_netmask('128') )
105
+ assert_not_nil(IPAdmin.validate_ipv6_netmask('/128') )
106
+ assert_not_nil(IPAdmin.validate_ipv6_netmask(128) )
103
107
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('0') }
104
108
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('129') }
105
109
  assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('128z') }
110
+ assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('1f') }
106
111
  end
107
112
 
108
113
 
109
114
  def test_compare
110
- ip4_1 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.1/24')
111
- ip4_2 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.2/24')
112
115
 
113
116
  cidr4_1 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
114
117
  cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/25')
115
118
  cidr4_3 = IPAdmin::CIDR.new(:CIDR => '192.168.2.0/24')
116
119
  cidr4_4 = IPAdmin::CIDR.new(:CIDR => '192.168.2.64/26')
117
120
  cidr4_5 = IPAdmin::CIDR.new(:CIDR => '192.168.1.128/25')
118
-
119
- ip6_1 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::1/64')
120
- ip6_2 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::2/64')
121
-
121
+
122
122
  cidr6_1 = IPAdmin::CIDR.new(:CIDR => 'fec0::0/10')
123
123
  cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::0/64')
124
124
  cidr6_3 = IPAdmin::CIDR.new(:CIDR => 'fe80::0/10')
@@ -133,10 +133,7 @@ class TestFunct < Test::Unit::TestCase
133
133
  comp7 = IPAdmin.compare(cidr6_1,cidr6_1)
134
134
  comp8 = IPAdmin.compare(cidr6_1,cidr6_3)
135
135
  comp9 = IPAdmin.compare(cidr4_2,cidr4_5)
136
- comp10 = IPAdmin.compare(ip4_1,ip4_2)
137
- comp11 = IPAdmin.compare(ip6_1,ip6_2)
138
- comp12 = IPAdmin.compare(cidr4_1,ip4_2)
139
- comp13 = IPAdmin.compare(cidr6_1,ip6_2)
136
+
140
137
 
141
138
  assert_equal([cidr4_1,cidr4_2],comp1)
142
139
  assert_equal([cidr4_3,cidr4_4],comp2)
@@ -147,37 +144,35 @@ class TestFunct < Test::Unit::TestCase
147
144
  assert_equal(1,comp7)
148
145
  assert_nil(comp8)
149
146
  assert_nil(comp9)
150
- assert_nil(comp10)
151
- assert_nil(comp11)
152
- assert_equal([cidr4_1,ip4_2],comp12)
153
- assert_equal([cidr6_1,ip6_2],comp13)
154
147
  end
155
148
 
156
149
 
157
150
  def test_range
158
- ip4_1 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.0')
159
- ip4_2 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.50')
160
- ip6_1 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::0')
161
- ip6_2 = IPAdmin::IPAddr.new(:IPAddr => 'fec0::32')
162
-
163
- assert_equal(['192.168.1.1'], IPAdmin.range(:Boundaries => [ip4_1,ip4_2], :Limit => 1) )
164
- assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0001'], IPAdmin.range(:Boundaries => [ip6_1,ip6_2], :Limit => 1) )
151
+ cidr4_1 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
152
+ cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.50/24')
153
+ cidr4_3 = IPAdmin::CIDR.new(:CIDR => '192.168.1.2/24')
154
+ cidr6_1 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
155
+ cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::32/64')
165
156
 
166
- list = IPAdmin.range(:Boundaries => [ip4_1,ip4_2], :Bitstep => 2)
157
+ assert_equal(['192.168.1.1'], IPAdmin.range(:Boundaries => [cidr4_1,cidr4_2], :Limit => 1) )
158
+ assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0001'], IPAdmin.range(:Boundaries => [cidr6_1,cidr6_2], :Limit => 1) )
167
159
 
160
+ list = IPAdmin.range(:Boundaries => [cidr4_1,cidr4_2], :Bitstep => 2)
168
161
  assert_equal(25, list.length)
169
162
  assert_equal('192.168.1.49', list[24])
170
163
 
164
+ list = IPAdmin.range(:Boundaries => [cidr4_1,cidr4_3], :Objectify => 2)
165
+ assert_kind_of(IPAdmin::CIDR, list[0])
166
+ assert_equal('192.168.1.1/32', (list[0]).desc)
167
+
171
168
  assert_raise(ArgumentError){ IPAdmin.range(:Limit => 1) }
172
169
  assert_raise(RuntimeError){ IPAdmin.range(:Boundaries => [1,2]) }
173
170
  end
174
171
 
175
172
  def test_arpa
176
- ip4 = IPAdmin::IPAddr.new(:IPAddr => '192.168.1.0/24')
177
173
  cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
178
174
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fe80::0/64')
179
175
 
180
- assert_equal('0.1.168.192.in-addr.arpa.', IPAdmin.arpa(ip4) )
181
176
  assert_equal('1.168.192.in-addr.arpa.', IPAdmin.arpa(cidr4) )
182
177
  assert_equal('0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.', IPAdmin.arpa(cidr6) )
183
178
 
@@ -187,10 +182,79 @@ class TestFunct < Test::Unit::TestCase
187
182
 
188
183
  def test_shorten
189
184
  assert_equal('fec0::', IPAdmin.shorten('fec0:0000:0000:0000:0000:0000:0000:0000') )
190
- assert_equal('fec0::2:0:0:1', IPAdmin.shorten('fec0:0000:0000:0000:0002:0000:0000:0001') )
185
+ assert_equal('fec0::2:0:0:1', IPAdmin.shorten('fec0:0000:0000:0000:0002:0000:0000:0001') )
186
+ assert_equal('fec0::2:0:0:1', IPAdmin.shorten('fec0:00:0000:0:02:0000:0:1') )
187
+ assert_raise(RuntimeError){ IPAdmin.shorten('fec0::') }
191
188
  end
192
-
193
189
 
190
+ def test_unshorten
191
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000', IPAdmin.unshorten('fec0::') )
192
+ assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', IPAdmin.unshorten('fec0::2:0:0:1') )
193
+ assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', IPAdmin.unshorten('fec0:0:0:0:2:0:0:1') )
194
+ end
195
+
196
+ def test_merge
197
+ cidr4 = [IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24'),
198
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26'),
199
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.4/30'),
200
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.0/30'),
201
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.64/27'),
202
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.96/27'),
203
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.128/25'),
204
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/31'),
205
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/24'),
206
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.2/31'),
207
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.4/30'),
208
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.16/28'),
209
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.32/28'),
210
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.48/28'),
211
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/27'),
212
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.64/26'),
213
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.128/25'),
214
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/27'),
215
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/24')]
216
+
217
+ cidr4_2 = [IPAdmin::CIDR.new(:CIDR => '10.0.0.0/9'),
218
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/9'),
219
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.0/24'),
220
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.64/26'),
221
+ IPAdmin::CIDR.new(:CIDR => '10.1.0.128/26'),
222
+ IPAdmin::CIDR.new(:CIDR => '128.0.0.0/2'),
223
+ IPAdmin::CIDR.new(:CIDR => '129.0.0.0/2'),
224
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.0'),
225
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.1'),
226
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.3'),
227
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.4'),
228
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.5'),
229
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.6'),
230
+ IPAdmin::CIDR.new(:CIDR => '1.1.1.7'),
231
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.0/27'),
232
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.32/27'),
233
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.96/27'),
234
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.128/26'),
235
+ IPAdmin::CIDR.new(:CIDR => '192.168.1.192/26')]
236
+
237
+ cidr6 = [IPAdmin::CIDR.new(:CIDR => 'fec0::/16'),
238
+ IPAdmin::CIDR.new(:CIDR => 'fec0::/17'),
239
+ IPAdmin::CIDR.new(:CIDR => 'fec0:8000::/18'),
240
+ IPAdmin::CIDR.new(:CIDR => 'fec0:c000::/18'),
241
+ IPAdmin::CIDR.new(:CIDR => 'fec0::/64'),
242
+ IPAdmin::CIDR.new(:CIDR => 'fec0::/66'),
243
+ IPAdmin::CIDR.new(:CIDR => 'fec0::8000:0:0:0/66'),
244
+ IPAdmin::CIDR.new(:CIDR => 'fec0::c000:0:0:0/66'),
245
+ IPAdmin::CIDR.new(:CIDR => 'fec0::/127'),
246
+ IPAdmin::CIDR.new(:CIDR => 'fec0::2/127')]
247
+
248
+ merge4 = IPAdmin.merge(:List => cidr4)
249
+ merge4_2 = IPAdmin.merge(:List => cidr4_2, :Objectify => 1)
250
+ merge6 = IPAdmin.merge(:List => cidr6)
251
+
252
+ assert_equal(5, merge4.length)
253
+ assert_equal(11, merge4_2.length)
254
+ assert_equal(5, merge6.length)
255
+
256
+ assert_equal('1.1.1.0/31', merge4_2[0].desc)
257
+ end
194
258
 
195
259
 
196
260
  end