src/Octet.hs

   1 module Octet (
   2   Octet(..),
   3   octet_from_int,
   4   octet_properties,
   5   octet_tests,
   6   )
   7 where
   8
   9 import Data.Maybe (fromJust)
  10 import Test.HUnit (assertEqual)
  11 import Test.Framework (Test, testGroup)
  12 import Test.Framework.Providers.HUnit (testCase)
  13 import Test.Framework.Providers.QuickCheck2 (testProperty)
  14 import Test.QuickCheck (Arbitrary(..), Gen, Property, (==>))
  15
  16 import Bit as B
  17 import Maskable
  18 import Maskbits
  19
  20 -- | An Octet consists of eight bits. For our purposes, the most
  21 --   significant bit will come "first." That is, b1 is in the 2^7
  22 --   place while b8 is in the 2^0 place.
  23 data Octet =
  24   Octet { b1 :: Bit,
  25           b2 :: Bit,
  26           b3 :: Bit,
  27           b4 :: Bit,
  28           b5 :: Bit,
  29           b6 :: Bit,
  30           b7 :: Bit,
  31           b8 :: Bit }
  32     deriving (Eq)
  33
  34
  35 instance Show Octet where
  36   show oct = show (fromEnum oct)
  37
  38
  39 instance Arbitrary Octet where
  40   arbitrary = do
  41     a1 <- arbitrary :: Gen Bit
  42     a2 <- arbitrary :: Gen Bit
  43     a3 <- arbitrary :: Gen Bit
  44     a4 <- arbitrary :: Gen Bit
  45     a5 <- arbitrary :: Gen Bit
  46     a6 <- arbitrary :: Gen Bit
  47     a7 <- arbitrary :: Gen Bit
  48     a8 <- arbitrary :: Gen Bit
  49     return (Octet a1 a2 a3 a4 a5 a6 a7 a8)
  50
  51
  52 instance Maskable Octet where
  53   apply_mask oct Eight _ =  oct
  54
  55   apply_mask oct Seven bit =
  56     oct { b8 = bit }
  57
  58   apply_mask oct Six bit =
  59     oct { b8 = bit, b7 = bit }
  60
  61   apply_mask oct Five bit =
  62     oct { b8 = bit, b7 = bit, b6 = bit }
  63
  64   apply_mask oct Four bit =
  65     oct { b8 = bit, b7 = bit, b6 = bit, b5 = bit }
  66
  67   apply_mask oct Three bit =
  68     oct { b8 = bit, b7 = bit, b6 = bit, b5 = bit, b4 = bit }
  69
  70   apply_mask oct Two bit =
  71     oct { b8 = bit, b7 = bit, b6 = bit, b5 = bit, b4 = bit, b3 = bit }
  72
  73   apply_mask oct Maskbits.One bit =
  74     oct { b8 = bit, b7 = bit, b6 = bit, b5 = bit,
  75           b4 = bit, b3 = bit, b2 = bit }
  76
  77   apply_mask oct Maskbits.Zero bit =
  78     oct { b8 = bit, b7 = bit, b6 = bit, b5 = bit,
  79           b4 = bit, b3 = bit, b2 = bit, b1 = bit }
  80
  81   -- The Maskbits must be in [Eight..ThirtyTwo].
  82   apply_mask oct _ _ = oct
  83
  84
  85 instance Ord Octet where
  86   (Octet x1 x2 x3 x4 x5 x6 x7 x8) <= (Octet y1 y2 y3 y4 y5 y6 y7 y8)
  87     | x1 > y1 = False
  88     | x2 > y2 = False
  89     | x3 > y3 = False
  90     | x4 > y4 = False
  91     | x5 > y5 = False
  92     | x6 > y6 = False
  93     | x7 > y7 = False
  94     | x8 > y8 = False
  95     | otherwise = True
  96
  97
  98 instance Bounded Octet where
  99   -- | The octet with the least possible value.
 100   minBound =
 101     Octet B.Zero B.Zero B.Zero B.Zero B.Zero B.Zero B.Zero B.Zero
 102
 103   -- | The octet with the greatest possible value.
 104   maxBound =
 105     Octet B.One B.One B.One B.One B.One B.One B.One B.One
 106
 107
 108 instance Enum Octet where
 109   -- We're supposed to throw a runtime error if you call (succ
 110   -- maxBound), so the fromJust here doesn't introduce any additional
 111   -- badness.
 112   toEnum = fromJust . octet_from_int
 113
 114   -- | Convert each bit to its integer value, and multiply by the
 115   --   appropriate power of two. Sum them up, and we should get an integer
 116   --   between 0 and 255.
 117   fromEnum x =
 118     128 * (bit_to_int (b1 x)) +
 119     64  * (bit_to_int (b2 x)) +
 120     32  * (bit_to_int (b3 x)) +
 121     16  * (bit_to_int (b4 x)) +
 122     8   * (bit_to_int (b5 x)) +
 123     4   * (bit_to_int (b6 x)) +
 124     2   * (bit_to_int (b7 x)) +
 125     1   * (bit_to_int (b8 x))
 126
 127
 128
 129 octet_from_int :: Int -> Maybe Octet
 130 octet_from_int x
 131   | (x < 0) || (x > 255) = Nothing
 132   | otherwise = Just (Octet a1 a2 a3 a4 a5 a6 a7 a8)
 133   where
 134     a1 = if (x >= 128) then B.One else B.Zero
 135     a2 = if ((x `mod` 128) >= 64) then B.One else B.Zero
 136     a3 = if ((x `mod` 64)  >= 32) then B.One else B.Zero
 137     a4 = if ((x `mod` 32)  >= 16) then B.One else B.Zero
 138     a5 = if ((x `mod` 16)  >= 8)  then B.One else B.Zero
 139     a6 = if ((x `mod` 8)   >= 4)  then B.One else B.Zero
 140     a7 = if ((x `mod` 4)   >= 2)  then B.One else B.Zero
 141     a8 = if ((x `mod` 2)   == 1)  then B.One else B.Zero
 142
 143
 144 instance Read Octet where
 145   readsPrec _ = \s ->
 146     case (reads s :: [(Int, String)]) of
 147       []              -> []
 148       (x,leftover):_  -> case (octet_from_int x) of
 149                            Nothing -> []
 150                            Just oct -> [(oct, leftover)]
 151
 152
 153 -- Test lists.
 154 octet_tests :: Test
 155 octet_tests =
 156   testGroup "Octet Tests" [
 157     test_octet_from_int1,
 158     test_octet_mask1,
 159     test_octet_mask2 ]
 160
 161 octet_properties :: Test
 162 octet_properties =
 163   testGroup
 164     "Octet Properties "
 165     [ testProperty
 166         "fromEnum/toEnum are inverses"
 167         prop_from_enum_to_enum_inverses,
 168       testProperty
 169         "read/show are inverses"
 170         prop_read_show_inverses ]
 171
 172 -- QuickCheck properties
 173 prop_from_enum_to_enum_inverses :: Int -> Property
 174 prop_from_enum_to_enum_inverses x =
 175   (0 <= x) && (x <= 255) ==>
 176     fromEnum (toEnum x :: Octet) == x
 177
 178 prop_read_show_inverses :: Int -> Property
 179 prop_read_show_inverses x =
 180   (0 <= x) && (x <= 255) ==> x' == x
 181   where
 182     oct :: Octet
 183     oct = read $ show x
 184
 185     x' :: Int
 186     x' = read $ show oct
 187
 188 -- HUnit Tests
 189 test_octet_from_int1 :: Test
 190 test_octet_from_int1 =
 191   testCase desc $ assertEqual desc oct1 oct2
 192   where
 193     desc = "octet_from_int 128 should parse as 10000000"
 194     oct1 = Octet B.One B.Zero B.Zero B.Zero B.Zero B.Zero B.Zero B.Zero
 195     oct2 = fromJust $ octet_from_int 128
 196
 197 test_octet_mask1 :: Test
 198 test_octet_mask1 =
 199   testCase desc $
 200     assertEqual desc oct2 (apply_mask oct1 Four B.Zero)
 201   where
 202     desc = "The network bits of 255/4 should equal 240"
 203     oct1 = fromJust $ octet_from_int 255
 204     oct2 = fromJust $ octet_from_int 240
 205
 206
 207 test_octet_mask2 :: Test
 208 test_octet_mask2 =
 209   testCase desc $
 210     assertEqual desc oct2 (apply_mask oct1 Maskbits.One B.Zero)
 211   where
 212     desc = "The network bits of 255/1 should equal 128"
 213     oct1 = fromJust $ octet_from_int 255
 214     oct2 = fromJust $ octet_from_int 128