ipadmin 0.2.1 → 0.2.2

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.
Files changed (8) hide show
  1. data/README +77 -13
  2. data/lib/cidr.rb +1459 -0
  3. data/lib/ip_admin.rb +3 -3682
  4. data/lib/methods.rb +2168 -0
  5. data/lib/tree.rb +735 -0
  6. data/tests/cidr_test.rb +34 -2
  7. data/tests/methods_test.rb +151 -102
  8. metadata +5 -2
data/tests/cidr_test.rb CHANGED
@@ -14,8 +14,29 @@ class TestCIDR < Test::Unit::TestCase
14
14
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::/64') )
15
15
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => '192.168.1.1/24') )
16
16
  assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::1/64') )
17
+ assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::1', :Netmask => 64) )
18
+ assert_not_nil(IPAdmin::CIDR.new(:PackedIP => 0x0a0a0a0a, :PackedNetmask => 0xffffffff) )
19
+
20
+ cidr = IPAdmin::CIDR.new(:CIDR => 'fec0::1', :Netmask => 64)
21
+ assert_equal(64, cidr.bits )
22
+
23
+ cidr = IPAdmin::CIDR.new(:CIDR => 'fec0::1/60', :Netmask => 64)
24
+ assert_equal(60, cidr.bits )
25
+
26
+ cidr = IPAdmin::CIDR.new(:CIDR => '10.10.10.10', :PackedIP => 0x0a0000000)
27
+ assert_equal(0x0a0000000, cidr.packed_ip )
28
+
29
+ cidr = IPAdmin::CIDR.new(:CIDR => '10.10.10.10/32', :Netmask => 24)
30
+ assert_equal(32, cidr.bits )
31
+
32
+ cidr = IPAdmin::CIDR.new(:CIDR => '10.10.10.10/32', :PackedNetmask => 0xffffff00)
33
+ assert_equal(24, cidr.bits )
34
+
35
+ assert_raise(ArgumentError){ IPAdmin::CIDR.new(1) }
36
+ assert_raise(ArgumentError){ IPAdmin::CIDR.new(:Version => 4, :Netmask => 32) }
17
37
  end
18
38
 
39
+
19
40
  def test_contains?
20
41
 
21
42
  cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
@@ -28,7 +49,10 @@ class TestCIDR < Test::Unit::TestCase
28
49
  assert_equal(true,cidr4.contains?(cidr4_2) )
29
50
  assert_equal(true,cidr6.contains?(cidr6_2) )
30
51
  assert_equal(false,cidr4.contains?(cidr4_3) )
31
- assert_equal(false,cidr6.contains?(cidr6_3) )
52
+ assert_equal(false,cidr6.contains?(cidr6_3) )
53
+
54
+ assert_raise(ArgumentError) { cidr4.contains?(1) }
55
+ assert_raise(ArgumentError) { cidr4.contains?(cidr6_2) }
32
56
  end
33
57
 
34
58
  def test_nth
@@ -36,20 +60,25 @@ class TestCIDR < Test::Unit::TestCase
36
60
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/126')
37
61
 
38
62
  assert_equal('192.168.1.1',cidr4.nth(:Index => 1) )
63
+ assert_equal('192.168.1.50',cidr4.nth(:Index => 50) )
39
64
  assert_kind_of(IPAdmin::CIDR,cidr4.nth(:Index => 1, :Objectify => true) )
40
65
  assert_raise(RuntimeError){ cidr4.nth(:Index => 256) }
41
66
  assert_raise(ArgumentError){ cidr4.nth() }
42
67
 
43
68
  assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.nth(:Index => 1) )
69
+ assert_equal('fec0:0000:0000:0000:0000:0000:0000:0003',cidr6.nth(:Index => 3) )
44
70
  assert_equal('fec0::1',cidr6.nth(:Index => 1, :Short => true) )
45
71
  assert_raise(RuntimeError){ cidr6.nth(:Index => 10) }
72
+
73
+ assert_raise(ArgumentError) { cidr4.nth(1) }
74
+ assert_raise(ArgumentError) { cidr4.nth({}) }
46
75
  end
47
76
 
48
77
  def test_enumerate
49
78
  cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
50
79
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
51
80
 
52
- assert_equal(['192.168.1.0'],cidr4.enumerate(:Limit => 1) )
81
+ assert_equal(['192.168.1.0', '192.168.1.1'],cidr4.enumerate(:Limit => 2) )
53
82
  assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0000'],cidr6.enumerate(:Limit => 1) )
54
83
  assert_equal(['fec0::'],cidr6.enumerate(:Limit => 1, :Short => true) )
55
84
 
@@ -161,6 +190,9 @@ class TestCIDR < Test::Unit::TestCase
161
190
  cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::1/64')
162
191
  cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::/96')
163
192
 
193
+ assert_equal('1.168.192.in-addr.arpa.', cidr4.arpa() )
194
+ assert_equal('0.0.0.0.0.0.0.0.0.0.0.0.0.c.e.f.ip6.arpa.', cidr6.arpa() )
195
+
164
196
  assert_equal('192.168.1.0/24',cidr4.desc() )
165
197
  assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/64',cidr6.desc() )
166
198
 
data/tests/methods_test.rb CHANGED
@@ -7,112 +7,146 @@ require 'test/unit'
7
7
 
8
8
  class TestMethods < Test::Unit::TestCase
9
9
 
10
- def test_pack_ipv4_addr
11
- assert_equal(2**32-1, IPAdmin.pack_ipv4_addr('255.255.255.255') )
12
- end
13
-
14
-
15
- def test_pack_ipv4_netmask
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
- end
21
-
22
-
23
- def test_pack_ipv6_addr
24
- assert_equal(2**128-1, IPAdmin.pack_ipv6_addr('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
25
- assert_equal(1, IPAdmin.pack_ipv6_addr('::1') )
26
- end
27
-
28
-
29
- def test_pack_ipv6_netmask
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
- end
34
-
35
-
36
- def test_unpack_ipv4_addr
37
- assert_equal('255.255.255.255', IPAdmin.unpack_ipv4_addr(2**32-1) )
38
- end
39
-
40
-
41
- def test_unpack_ipv4_netmask
42
- assert_equal(32, IPAdmin.unpack_ipv4_netmask(2**32-1) )
43
- end
44
-
45
-
46
- def test_unpack_ipv6_addr
47
- assert_equal('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', IPAdmin.unpack_ipv6_addr(2**128-1) )
10
+ def test_pack_ip_addr
11
+ assert_equal(2**128-1, IPAdmin.pack_ip_addr(:IP => 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
12
+ assert_equal(1, IPAdmin.pack_ip_addr(:IP => '::1') )
13
+ assert_equal(2**32-1, IPAdmin.pack_ip_addr(:IP => '255.255.255.255') )
14
+ assert_equal(2**128-1, IPAdmin.pack_ip_addr(:IP => 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255') )
15
+ assert_equal(0, IPAdmin.pack_ip_addr(:IP => '::') )
16
+ assert_equal(2**32-1, IPAdmin.pack_ip_addr(:IP => '::255.255.255.255') )
17
+ assert_equal(0x0a0a0a0a, IPAdmin.pack_ip_addr(:IP => '10.10.10.10') )
18
+ assert_equal(2**127+1, IPAdmin.pack_ip_addr(:IP => '8000::0.0.0.1') )
19
+ assert_equal(0x8080000000000000000080800a0a0a0a, IPAdmin.pack_ip_addr(:IP => '8080::8080:10.10.10.10') )
20
+ assert_equal(0xffff0a010001, IPAdmin.pack_ip_addr(:IP => '::ffff:10.1.0.1') )
21
+ assert_equal(2**127+1, IPAdmin.pack_ip_addr(:IP => '8000::1') )
22
+ assert_equal(1, IPAdmin.pack_ip_addr(:IP => '::1') )
23
+ assert_equal(2**127, IPAdmin.pack_ip_addr(:IP => '8000::') )
24
+
25
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_addr('192.168.1.1') }
26
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_addr({}) }
27
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_addr(:IP => '192.168.1.1',:Version => 5) }
28
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_addr(:IP => 0xffffffff,:Version => 4) }
48
29
  end
49
30
 
50
31
 
51
- def test_unpack_ipv6_netmask
52
- assert_equal(128, IPAdmin.unpack_ipv6_netmask(2**128-1) )
32
+ def test_pack_ip_netmask
33
+ assert_equal(2**32-1, IPAdmin.pack_ip_netmask(:Netmask => '255.255.255.255') )
34
+ assert_equal(2**32-1, IPAdmin.pack_ip_netmask(:Netmask => '32') )
35
+ assert_equal(2**32-1, IPAdmin.pack_ip_netmask(:Netmask => '/32') )
36
+ assert_equal(2**32-1, IPAdmin.pack_ip_netmask(:Netmask => 32) )
37
+ assert_equal(2**128-1, IPAdmin.pack_ip_netmask(:Netmask => '128', :Version => 6) )
38
+ assert_equal(2**128-1, IPAdmin.pack_ip_netmask(:Netmask => '/128', :Version => 6) )
39
+ assert_equal(2**128-1, IPAdmin.pack_ip_netmask(:Netmask => 128, :Version => 6) )
40
+
41
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_netmask(24) }
42
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_netmask({}) }
43
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_netmask(:Netmask => '/24',:Version => 5) }
44
+ assert_raise(ArgumentError){ IPAdmin.pack_ip_netmask(:Netmask => [],:Version => 4) }
53
45
  end
54
46
 
55
47
 
56
- def test_validate_ipv4_addr
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') )
60
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1.256') }
61
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192..168.1.1') }
62
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('0.168.1.1') }
63
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1a.255') }
64
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('192.168.1.1.1') }
65
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('ffff::1111:1111') }
66
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_addr('ff.ff.ff.ff') }
48
+ def test_unpack_ip_addr
49
+ assert_equal('255.255.255.255', IPAdmin.unpack_ip_addr(:Integer => 2**32-1) )
50
+ assert_equal('0.0.0.0', IPAdmin.unpack_ip_addr(:Integer => 0, :Version => 4) )
51
+ assert_equal('0000:0000:0000:0000:0000:0000:0000:0000', IPAdmin.unpack_ip_addr(:Integer => 0, :Version => 6) )
52
+ assert_equal('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', IPAdmin.unpack_ip_addr(:Integer => 2**128-1) )
53
+ assert_equal('0000:0000:0000:0000:0000:0000:ffff:ffff', IPAdmin.unpack_ip_addr(:Integer => 2**32-1, :Version => 6) )
54
+ assert_equal('0000:0000:0000:0000:0000:ffff:10.1.0.1', IPAdmin.unpack_ip_addr(:Integer => 0xffff0a010001,
55
+ :IPv4Mapped => true,
56
+ :Version => 6) )
57
+
58
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_addr('1') }
59
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_addr({}) }
60
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_addr(:Integer => 0xffffffff,:Version => 5) }
61
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_addr(:Integer => '1', :Version => 4) }
67
62
  end
68
63
 
69
64
 
70
- def test_validate_ipv4_netmask
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') )
77
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('192.255.255.0') }
78
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('255.255.255.194') }
79
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('256.255.255.0') }
80
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('0') }
81
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('33') }
82
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('3a') }
83
- assert_raise(RuntimeError){ IPAdmin.validate_ipv4_netmask('ff.ff.ff.ff') }
65
+ def test_unpack_ip_netmask
66
+ assert_equal(32, IPAdmin.unpack_ip_netmask(:Integer => 2**32-1) )
67
+ assert_equal(24, IPAdmin.unpack_ip_netmask(:Integer => (2**32 - 2**8 ) ) )
68
+ assert_equal(128, IPAdmin.unpack_ip_netmask(:Integer => 2**128-1) )
69
+ assert_equal(96, IPAdmin.unpack_ip_netmask(:Integer => (2**128 - 2**32)) )
70
+
71
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_netmask('1') }
72
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_netmask({}) }
73
+ assert_raise(ArgumentError){ IPAdmin.unpack_ip_netmask(:Integer => '1')}
84
74
  end
85
75
 
86
76
 
87
- def test_validate_ipv6_addr
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') )
94
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('ffff::1111::1111') }
95
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('abcd:efgh::1') }
96
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_addr('fffff::1') }
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') }
77
+ def test_validate_ip_addr
78
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '192.168.1.0') )
79
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '255.255.255.255') )
80
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '224.0.0.1') )
81
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '0.192.0.1') )
82
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '0.0.0.0') )
83
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 0xff0000) )
84
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 2**32-1) )
85
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 0) )
86
+
87
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
88
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '::') )
89
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 'ffff::1') )
90
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '1234:5678:9abc:def0:1234:5678:9abc:def0') )
91
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '::1') )
92
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 'ffff::') )
93
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '0001::1') )
94
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '2001:4800::64.39.2.1') )
95
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '::1.1.1.1') )
96
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '::192.168.255.0') )
97
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 2**128-1) )
98
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => 'fec0:0:0:0:0:0:192.168.1.1') )
99
+ assert_not_nil(IPAdmin.validate_ip_addr(:IP => '8080::8080:10.10.10.10') )
100
+
101
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '') }
102
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '10.0') }
103
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '192.168.1.256') }
104
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '192..168.1.1') }
105
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '192.168.1a.255') }
106
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '192.168.1.1.1') }
107
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'ff.ff.ff.ff') }
108
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 2**128-1, :Version => 4) }
109
+
110
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'ffff::1111::1111') }
111
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'abcd:efgh::1') }
112
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'fffff::1') }
113
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'fffg::1') }
114
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => 'ffff:::0::1') }
115
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '1:0:0:0:0:0:0:0:1') }
116
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '::192.168.256.0') }
117
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '::192.168.a3.0') }
118
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_addr(:IP => '::192.168.1.1.0') }
119
+
120
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_addr('1') }
121
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_addr({}) }
122
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_addr(:IP => [])}
123
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_addr(:IP => '192.168.1.0', :Version => 5)}
124
+
99
125
  end
100
126
 
101
127
 
102
- def test_validate_ipv6_netmask
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) )
107
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('0') }
108
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('129') }
109
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('128z') }
110
- assert_raise(RuntimeError){ IPAdmin.validate_ipv6_netmask('1f') }
128
+ def test_validate_ip_netmask
129
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => '255.255.255.255') )
130
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => '32') )
131
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => '/32') )
132
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => 32) )
133
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => 0xffffffff, :Packed => true) )
134
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => '128', :Version => 6) )
135
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => '/128', :Version => 6) )
136
+ assert_equal(true, IPAdmin.validate_ip_netmask(:Netmask => 128, :Version => 6) )
137
+
138
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_netmask(:Netmask => '255.192.255.0') }
139
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_netmask(:Netmask => 33) }
140
+ assert_raise(RuntimeError){ IPAdmin.validate_ip_netmask(:Netmask => 129, :Version => 6) }
141
+
142
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_netmask('1') }
143
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_netmask({}) }
144
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_netmask(:Netmask => [])}
145
+ assert_raise(ArgumentError){ IPAdmin.validate_ip_netmask(:Netmask => '/24', :Version => 5)}
111
146
  end
112
147
 
113
148
 
114
- def test_compare
115
-
149
+ def test_compare
116
150
  cidr4_1 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
117
151
  cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/25')
118
152
  cidr4_3 = IPAdmin::CIDR.new(:CIDR => '192.168.2.0/24')
@@ -133,7 +167,6 @@ class TestMethods < Test::Unit::TestCase
133
167
  comp7 = IPAdmin.compare(cidr6_1,cidr6_1)
134
168
  comp8 = IPAdmin.compare(cidr6_1,cidr6_3)
135
169
  comp9 = IPAdmin.compare(cidr4_2,cidr4_5)
136
-
137
170
 
138
171
  assert_equal([cidr4_1,cidr4_2],comp1)
139
172
  assert_equal([cidr4_3,cidr4_4],comp2)
@@ -144,6 +177,19 @@ class TestMethods < Test::Unit::TestCase
144
177
  assert_equal(1,comp7)
145
178
  assert_nil(comp8)
146
179
  assert_nil(comp9)
180
+
181
+ assert_raise(ArgumentError){ IPAdmin.compare('1',cidr4_2) }
182
+ assert_raise(ArgumentError){ IPAdmin.compare(cidr4_2, '1') }
183
+ assert_raise(ArgumentError){ IPAdmin.compare(cidr4_1,cidr6_1)}
184
+ end
185
+
186
+
187
+ def test_minimum_size
188
+ assert_equal(24, IPAdmin.minimum_size(:IPCount => 200))
189
+ assert_equal(96, IPAdmin.minimum_size(:IPCount => 2**32-1, :Version => 6))
190
+
191
+ assert_raise(ArgumentError){ IPAdmin.minimum_size(1) }
192
+ assert_raise(ArgumentError){ IPAdmin.minimum_size({}) }
147
193
  end
148
194
 
149
195
 
@@ -166,19 +212,11 @@ class TestMethods < Test::Unit::TestCase
166
212
  assert_equal('192.168.1.1/32', (list[0]).desc)
167
213
 
168
214
  assert_raise(ArgumentError){ IPAdmin.range(:Limit => 1) }
169
- assert_raise(RuntimeError){ IPAdmin.range(:Boundaries => [1,2]) }
215
+ assert_raise(ArgumentError){ IPAdmin.range(:Boundaries => [1,2]) }
216
+ assert_raise(ArgumentError){ IPAdmin.compare('1') }
217
+ assert_raise(ArgumentError){ IPAdmin.range(:Boundaries => [cidr4_1,cidr6_2]) }
170
218
  end
171
219
 
172
- def test_arpa
173
- cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
174
- cidr6 = IPAdmin::CIDR.new(:CIDR => 'fe80::0/64')
175
-
176
- assert_equal('1.168.192.in-addr.arpa.', IPAdmin.arpa(cidr4) )
177
- assert_equal('0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.', IPAdmin.arpa(cidr6) )
178
-
179
- assert_raise(ArgumentError){ IPAdmin.arpa('192.168.1.0/24') }
180
- assert_raise(ArgumentError){ IPAdmin.arpa('fec0::') }
181
- end
182
220
 
183
221
  def test_shorten
184
222
  assert_equal('fec0::', IPAdmin.shorten('fec0:0000:0000:0000:0000:0000:0000:0000') )
@@ -189,15 +227,23 @@ class TestMethods < Test::Unit::TestCase
189
227
  assert_equal('fec0:1:1:1:1:1:1:1', IPAdmin.shorten('fec0:0001:0001:0001:0001:0001:0001:0001') )
190
228
  assert_equal('fec0:ffff:ffff:0:ffff:ffff:ffff:ffff', IPAdmin.shorten('fec0:ffff:ffff:0000:ffff:ffff:ffff:ffff') )
191
229
  assert_equal('fec0:ffff:ffff:ffff:ffff:ffff:ffff:ffff', IPAdmin.shorten('fec0:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
192
- assert_equal('fec0::', IPAdmin.shorten('fec0::') )
230
+ assert_equal('fec0::', IPAdmin.shorten('fec0::') )
231
+ assert_equal('fec0::192.168.1.1', IPAdmin.shorten('fec0:0:0:0:0:0:192.168.1.1') )
232
+
233
+ assert_raise(ArgumentError){ IPAdmin.shorten(1) }
193
234
  end
194
235
 
236
+
195
237
  def test_unshorten
196
238
  assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000', IPAdmin.unshorten('fec0::') )
197
239
  assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', IPAdmin.unshorten('fec0::2:0:0:1') )
198
- assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', IPAdmin.unshorten('fec0:0:0:0:2:0:0:1') )
240
+ assert_equal('fec0:0000:0000:0000:0002:0000:0000:0001', IPAdmin.unshorten('fec0:0:0:0:2:0:0:1') )
241
+ assert_equal('0000:0000:0000:0000:0000:ffff:10.1.0.1', IPAdmin.unshorten('::ffff:10.1.0.1') )
242
+
243
+ assert_raise(ArgumentError){ IPAdmin.unshorten(1) }
199
244
  end
200
245
 
246
+
201
247
  def test_merge
202
248
  cidr4 = [IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24'),
203
249
  IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26'),
@@ -259,6 +305,9 @@ class TestMethods < Test::Unit::TestCase
259
305
  assert_equal(5, merge6.length)
260
306
 
261
307
  assert_equal('1.1.1.0/31', merge4_2[0].desc)
308
+
309
+ assert_raise(ArgumentError){ IPAdmin.merge(1) }
310
+ assert_raise(ArgumentError){ IPAdmin.merge({}) }
262
311
  end
263
312
 
264
313
 
metadata CHANGED
@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
3
3
  specification_version: 1
4
4
  name: ipadmin
5
5
  version: !ruby/object:Gem::Version
6
- version: 0.2.1
7
- date: 2006-03-08 00:00:00 -06:00
6
+ version: 0.2.2
7
+ date: 2006-03-24 00:00:00 -06:00
8
8
  summary: A package for manipulating IPv4/IPv6 address space.
9
9
  require_paths:
10
10
  - lib
@@ -30,6 +30,9 @@ authors:
30
30
  - Dustin Spinhirne
31
31
  files:
32
32
  - lib/ip_admin.rb
33
+ - lib/tree.rb
34
+ - lib/cidr.rb
35
+ - lib/methods.rb
33
36
  - README
34
37
  test_files:
35
38
  - tests/methods_test.rb