ipadmin 0.2.1 → 0.2.2

Sign up to get free protection for your applications and to get access to all the features.
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