Add some more tests; minor code cleanup.

[hath.git] / src / Octet.hs

diff --git a/src/Octet.hs b/src/Octet.hs
index 531d4d071f051e0124e57fa3417e167e8cb70542..574edc435a90f4f50a860b118e96ef0f75c9a32f 100644 (file)
--- a/src/Octet.hs
+++ b/src/Octet.hs
@@ -1,13 +1,17 @@
-module Octet
+module Octet (
+  Octet(..),
+  octet_from_int,
+  octet_properties,
+  octet_tests,
+  )
 where
 
 import Data.Maybe (fromJust)
-
 import Test.HUnit (assertEqual)
 import Test.Framework (Test, testGroup)
 import Test.Framework.Providers.HUnit (testCase)
-
-import Test.QuickCheck (Arbitrary(..), Gen)
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.QuickCheck (Arbitrary(..), Gen, Property, (==>))
 
 import Bit as B
 import Maskable
@@ -29,7 +33,7 @@ data Octet =
 
 
 instance Show Octet where
-  show oct = show (octet_to_int oct)
+  show oct = show (fromEnum oct)
 
 
 instance Arbitrary Octet where
@@ -106,21 +110,19 @@ instance Enum Octet where
   -- maxBound), so the fromJust here doesn't introduce any additional
   -- badness.
   toEnum = fromJust . octet_from_int
-  fromEnum = octet_to_int
 
--- | Convert each bit to its integer value, and multiply by the
---   appropriate power of two. Sum them up, and we should get an integer
---   between 0 and 255.
-octet_to_int :: Octet -> Int
-octet_to_int x =
-  128 * (bit_to_int (b1 x)) +
-  64  * (bit_to_int (b2 x)) +
-  32  * (bit_to_int (b3 x)) +
-  16  * (bit_to_int (b4 x)) +
-  8   * (bit_to_int (b5 x)) +
-  4   * (bit_to_int (b6 x)) +
-  2   * (bit_to_int (b7 x)) +
-  1   * (bit_to_int (b8 x))
+  -- | Convert each bit to its integer value, and multiply by the
+  --   appropriate power of two. Sum them up, and we should get an integer
+  --   between 0 and 255.
+  fromEnum x =
+    128 * (bit_to_int (b1 x)) +
+    64  * (bit_to_int (b2 x)) +
+    32  * (bit_to_int (b3 x)) +
+    16  * (bit_to_int (b4 x)) +
+    8   * (bit_to_int (b5 x)) +
+    4   * (bit_to_int (b6 x)) +
+    2   * (bit_to_int (b7 x)) +
+    1   * (bit_to_int (b8 x))
 
 
 
@@ -139,13 +141,49 @@ octet_from_int x
     a8 = if ((x `mod` 2)   == 1)  then B.One else B.Zero
 
 
-octet_from_string :: String -> Maybe Octet
-octet_from_string s =
-  case (reads s :: [(Int, String)]) of
-    []   -> Nothing
-    x:_ -> octet_from_int (fst x)
+instance Read Octet where
+  readsPrec _ = \s ->
+    case (reads s :: [(Int, String)]) of
+      []              -> []
+      (x,leftover):_  -> case (octet_from_int x) of
+                           Nothing -> []
+                           Just oct -> [(oct, leftover)]
+
 
+-- Test lists.
+octet_tests :: Test
+octet_tests =
+  testGroup "Octet Tests" [
+    test_octet_from_int1,
+    test_octet_mask1,
+    test_octet_mask2 ]
 
+octet_properties :: Test
+octet_properties =
+  testGroup
+    "Octet Properties "
+    [ testProperty
+        "fromEnum/toEnum are inverses"
+        prop_from_enum_to_enum_inverses,
+      testProperty
+        "read/show are inverses"
+        prop_read_show_inverses ]
+
+-- QuickCheck properties
+prop_from_enum_to_enum_inverses :: Int -> Property
+prop_from_enum_to_enum_inverses x =
+  (0 <= x) && (x <= 255) ==>
+    fromEnum (toEnum x :: Octet) == x
+
+prop_read_show_inverses :: Int -> Property
+prop_read_show_inverses x =
+  (0 <= x) && (x <= 255) ==> x' == x
+  where
+    oct :: Octet
+    oct = read $ show x
+
+    x' :: Int
+    x' = read $ show oct
 
 -- HUnit Tests
 test_octet_from_int1 :: Test
@@ -174,11 +212,3 @@ test_octet_mask2 =
     desc = "The network bits of 255/1 should equal 128"
     oct1 = fromJust $ octet_from_int 255
     oct2 = fromJust $ octet_from_int 128
-
-
-octet_tests :: Test
-octet_tests =
-  testGroup "Octet Tests" [
-    test_octet_from_int1,
-    test_octet_mask1,
-    test_octet_mask2 ]