3 ipv4address_properties,
5 most_sig_bit_different )
8 import Test.HUnit (assertEqual)
9 import Test.Framework (Test, testGroup)
10 import Test.Framework.Providers.HUnit (testCase)
11 import Test.Framework.Providers.QuickCheck2 (testProperty)
12 import Test.QuickCheck (Arbitrary(..), Gen, Property, (==>))
14 import Maskable (Maskable(..))
15 import Maskbits (Maskbits(..))
16 import Octet (Octet(..))
19 IPv4Address { octet1 :: Octet,
26 instance Show IPv4Address where
27 show addr = concat [(show oct1) ++ ".",
38 instance Arbitrary IPv4Address where
40 oct1 <- arbitrary :: Gen Octet
41 oct2 <- arbitrary :: Gen Octet
42 oct3 <- arbitrary :: Gen Octet
43 oct4 <- arbitrary :: Gen Octet
44 return (IPv4Address oct1 oct2 oct3 oct4)
48 instance Maskable IPv4Address where
50 apply_mask addr mask bit =
58 -- A copy of 'addr' with the fourth octet zeroed (or oned).
59 new_addr1 = addr { octet4 = (apply_mask oct4 Zero bit) }
61 -- Likewise for new_addr1's third octet.
62 new_addr2 = new_addr1 { octet3 = (apply_mask oct3 Zero bit) }
64 -- And new_addr2's second octet.
65 new_addr3 = new_addr2 { octet2 = (apply_mask oct2 Zero bit) }
67 -- This helper function allows us to pattern-match cleanly.
68 apply_mask' :: Maskbits -> IPv4Address
70 apply_mask' ThirtyTwo = addr
72 apply_mask' ThirtyOne = addr { octet4 = (apply_mask oct4 Seven bit) }
75 addr { octet4 = (apply_mask oct4 Six bit) }
77 apply_mask' TwentyNine =
78 addr { octet4 = (apply_mask oct4 Five bit) }
80 apply_mask' TwentyEight =
81 addr { octet4 = (apply_mask oct4 Four bit) }
83 apply_mask' TwentySeven =
84 addr { octet4 = (apply_mask oct4 Three bit) }
86 apply_mask' TwentySix =
87 addr { octet4 = (apply_mask oct4 Two bit) }
89 apply_mask' TwentyFive =
90 addr { octet4 = (apply_mask oct4 One bit) }
92 apply_mask' TwentyFour = new_addr1
94 apply_mask' TwentyThree =
95 new_addr1 { octet3 = (apply_mask oct3 Seven bit) }
97 apply_mask' TwentyTwo =
98 new_addr1 { octet3 = (apply_mask oct3 Six bit) }
100 apply_mask' TwentyOne =
101 new_addr1 { octet3 = (apply_mask oct3 Five bit) }
104 new_addr1 { octet3 = (apply_mask oct3 Four bit) }
106 apply_mask' Nineteen =
107 new_addr1 { octet3 = (apply_mask oct3 Three bit) }
109 apply_mask' Eighteen =
110 new_addr1 { octet3 = (apply_mask oct3 Two bit) }
112 apply_mask' Seventeen =
113 new_addr1 { octet3 = (apply_mask oct3 One bit) }
115 apply_mask' Sixteen =
118 apply_mask' Fifteen =
119 new_addr2 { octet2 = (apply_mask oct2 Seven bit) }
121 apply_mask' Fourteen =
122 new_addr2 { octet2 = (apply_mask oct2 Six bit) }
124 apply_mask' Thirteen =
125 new_addr2 { octet2 = (apply_mask oct2 Five bit) }
128 new_addr2 { octet2 = (apply_mask oct2 Four bit) }
131 new_addr2 { octet2 = (apply_mask oct2 Three bit) }
134 new_addr2 { octet2 = (apply_mask oct2 Two bit) }
137 new_addr2 { octet2 = (apply_mask oct2 One bit) }
140 new_addr3 { octet2 = (apply_mask oct2 Zero bit) }
143 new_addr3 { octet1 = (apply_mask oct1 Seven bit) }
146 new_addr3 { octet1 = (apply_mask oct1 Six bit) }
149 new_addr3 { octet1 = (apply_mask oct1 Five bit) }
152 new_addr3 { octet1 = (apply_mask oct1 Four bit) }
155 new_addr3 { octet1 = (apply_mask oct1 Three bit) }
158 new_addr3 { octet1 = (apply_mask oct1 Two bit) }
161 new_addr3 { octet1 = (apply_mask oct1 One bit) }
164 new_addr3 { octet1 = (apply_mask oct1 Zero bit) }
167 instance Bounded IPv4Address where
168 -- | The minimum possible IPv4 address, 0.0.0.0.
169 minBound = IPv4Address minBound minBound minBound minBound
171 -- | The maximum possible IPv4 address, 255.255.255.255.
172 maxBound = IPv4Address maxBound maxBound maxBound maxBound
177 instance Enum IPv4Address where
178 -- | Convert an 'Int' @x@ to an 'IPv4Address'. Each octet of @x@ is
179 -- right-shifted by the appropriate number of bits, and the fractional
182 IPv4Address oct1 oct2 oct3 oct4
184 -- Chop off the higher octets. x1 = x `mod` 2^32, would be
186 x2 = x `mod` 2^(24 :: Integer)
187 x3 = x `mod` 2^(16 :: Integer)
188 x4 = x `mod` 2^(8 :: Integer)
189 -- Perform right-shifts. x4 doesn't need a shift.
190 shifted_x1 = x `quot` 2^(24 :: Integer)
191 shifted_x2 = x2 `quot` 2^(16 :: Integer)
192 shifted_x3 = x3 `quot` 2^(8 :: Integer)
193 oct1 = toEnum shifted_x1
194 oct2 = toEnum shifted_x2
195 oct3 = toEnum shifted_x3
198 -- | Convert @addr@ to an 'Int' by converting each octet to an 'Int'
199 -- and shifting the result to the left by 0,8.16, or 24 bits.
201 (shifted_oct1) + (shifted_oct2) + (shifted_oct3) + oct4
203 oct1 = fromEnum (octet1 addr)
204 oct2 = fromEnum (octet2 addr)
205 oct3 = fromEnum (octet3 addr)
206 oct4 = fromEnum (octet4 addr)
207 shifted_oct1 = oct1 * 2^(24 :: Integer)
208 shifted_oct2 = oct2 * 2^(16 :: Integer)
209 shifted_oct3 = oct3 * 2^(8 :: Integer)
211 -- | Given two addresses, find the number of the most significant bit
212 -- where they differ. If the addresses are the same, return
214 most_sig_bit_different :: IPv4Address -> IPv4Address -> Maskbits
215 most_sig_bit_different addr1 addr2
216 | addr1 == addr2 = Maskbits.Zero
217 | m1 /= n1 = Maskbits.One
227 | m11 /= n11 = Eleven
228 | m12 /= n12 = Twelve
229 | m13 /= n13 = Thirteen
230 | m14 /= n14 = Fourteen
231 | m15 /= n15 = Fifteen
232 | m16 /= n16 = Sixteen
233 | m17 /= n17 = Seventeen
234 | m18 /= n18 = Eighteen
235 | m19 /= n19 = Nineteen
236 | m20 /= n20 = Twenty
237 | m21 /= n21 = TwentyOne
238 | m22 /= n22 = TwentyTwo
239 | m23 /= n23 = TwentyThree
240 | m24 /= n24 = TwentyFour
241 | m25 /= n25 = TwentyFive
242 | m26 /= n26 = TwentySix
243 | m27 /= n27 = TwentySeven
244 | m28 /= n28 = TwentyEight
245 | m29 /= n29 = TwentyNine
246 | m30 /= n30 = Thirty
247 | m31 /= n31 = ThirtyOne
248 | m32 /= n32 = ThirtyTwo
249 | otherwise = Maskbits.Zero
283 oct1a = (octet1 addr1)
284 oct2a = (octet2 addr1)
285 oct3a = (octet3 addr1)
286 oct4a = (octet4 addr1)
319 oct1b = (octet1 addr2)
320 oct2b = (octet2 addr2)
321 oct3b = (octet3 addr2)
322 oct4b = (octet4 addr2)
326 ipv4address_tests :: Test
328 testGroup "IPv4 Address Tests" [
332 test_most_sig_bit_different1,
333 test_most_sig_bit_different2,
336 ipv4address_properties :: Test
337 ipv4address_properties =
339 "IPv4 Address Properties "
341 "fromEnum/toEnum are inverses"
342 prop_from_enum_to_enum_inverses ]
344 -- QuickCheck properties
345 prop_from_enum_to_enum_inverses :: Int -> Property
346 prop_from_enum_to_enum_inverses x =
347 (0 <= x) && (x <= 2^(32 :: Integer) - 1) ==>
348 fromEnum (toEnum x :: IPv4Address) == x
351 mk_testaddr :: Int -> Int -> Int -> Int -> IPv4Address
352 mk_testaddr a b c d =
353 IPv4Address oct1 oct2 oct3 oct4
360 test_minBound :: Test
362 testCase desc $ assertEqual desc expected actual
364 desc = "minBound should be 0.0.0.0"
365 expected = mk_testaddr 0 0 0 0
366 actual = minBound :: IPv4Address
368 test_maxBound :: Test
370 testCase desc $ assertEqual desc expected actual
372 desc = "maxBound should be 255.255.255.255"
373 expected = mk_testaddr 255 255 255 255
374 actual = maxBound :: IPv4Address
378 testCase desc $ assertEqual desc expected actual
380 desc = "enumerating a /24 gives the correct addresses"
381 expected = ["192.168.0." ++ (show x) | x <- [0..255::Int] ]
382 lb = mk_testaddr 192 168 0 0
383 ub = mk_testaddr 192 168 0 255
384 actual = map show [lb..ub]
386 test_most_sig_bit_different1 :: Test
387 test_most_sig_bit_different1 =
388 testCase desc $ assertEqual desc
392 desc = "10.1.1.0 and 10.1.0.0 differ in bit 24"
393 addr1 = mk_testaddr 10 1 1 0
394 addr2 = (mk_testaddr 10 1 0 0)
395 bit = most_sig_bit_different addr1 addr2
399 test_most_sig_bit_different2 :: Test
400 test_most_sig_bit_different2 =
401 testCase desc $ assertEqual desc
405 desc = "10.1.2.0 and 10.1.1.0 differ in bit 23"
406 addr1 = mk_testaddr 10 1 2 0
407 addr2 = mk_testaddr 10 1 1 0
408 bit = most_sig_bit_different addr1 addr2
413 testCase desc $ assertEqual desc expected actual
415 desc = "192.168.0.0 in base-10 is 3232235520"
416 expected = mk_testaddr 192 168 0 0
417 actual = toEnum 3232235520