diff --git a/inflections.cabal b/inflections.cabal
--- a/inflections.cabal
+++ b/inflections.cabal
@@ -1,5 +1,5 @@
 name:                inflections
-version:             0.1.0.10
+version:             0.2.0.0
 synopsis:            Inflections library for Haskell
 description:
   Inflections provides methods for singularization, pluralization,
@@ -60,3 +60,10 @@
       , containers
   ghc-options:         -Wall
   default-language:    Haskell2010
+  other-modules:
+    Text.InflectionsTest
+    Text.Inflections.HumanizeTest
+    Text.Inflections.OrdinalTest
+    Text.Inflections.Tests
+    Text.Inflections.TitleizeTest
+    Text.Inflections.UnderscoreTest
diff --git a/test/Text/Inflections/HumanizeTest.hs b/test/Text/Inflections/HumanizeTest.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/Inflections/HumanizeTest.hs
@@ -0,0 +1,26 @@
+module Text.Inflections.HumanizeTest where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.Framework (Test, testGroup)
+
+import Text.Inflections (humanize)
+import Text.Inflections.Parse.Types (Word(..))
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [ testGroup "humanize"
+          [ testCase "employee_salary -> Employee salary" test_humanize1
+          , testCase "underground -> underground" test_humanize2
+          ]
+        ]
+
+----------------------------------------------------
+
+test_humanize1 = "Employee salary" @?=
+                 humanize [Word "employee", Word "salary"]
+
+test_humanize2 = "Underground" @?= humanize [Word "underground"]
diff --git a/test/Text/Inflections/OrdinalTest.hs b/test/Text/Inflections/OrdinalTest.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/Inflections/OrdinalTest.hs
@@ -0,0 +1,57 @@
+module Text.Inflections.OrdinalTest where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.Framework (Test, testGroup)
+
+import Text.Inflections (ordinal, ordinalize)
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [ testGroup "ordinal"
+          [ testCase "1 -> st" test_ordinal1
+          , testCase "2 -> nd" test_ordinal2
+          , testCase "1002 -> nd" test_ordinal1002
+          , testCase "1003 -> rd" test_ordinal1003
+          , testCase "-11 -> th" test_ordinalNegative11
+          , testCase "-1021 -> st" test_ordinalNegative1021
+          , testProperty "notEmpty" prop_ordinalReturnsNotEmpty
+          ]
+        , testGroup "ordinalize"
+          [ testCase "1 -> st" test_ordinalize1
+          , testCase "-1021 -> st" test_ordinalizeNegative1021
+          , testProperty "result contains number" prop_ordinalizeSamePrefix
+          ]
+        ]
+
+----------------------------------------------------
+
+test_ordinal1 = "st" @?= ordinal 1
+
+test_ordinal2 = "nd" @?= ordinal 2
+
+test_ordinal1002 = "nd" @?= ordinal 1002
+
+test_ordinal1003 = "rd" @?= ordinal 1003
+
+test_ordinalNegative11 = "th" @?= ordinal (-11)
+
+test_ordinalNegative1021 = "st" @?= ordinal (-1021)
+
+----------------------------------------------------
+
+test_ordinalize1 = "1st" @?= ordinalize 1
+
+test_ordinalizeNegative1021 = "-1021st" @?= ordinalize (-1021)
+
+----------------------------------------------------
+
+prop_ordinalReturnsNotEmpty :: Integer -> Bool
+prop_ordinalReturnsNotEmpty = not . null . ordinal
+
+prop_ordinalizeSamePrefix :: Integer -> Bool
+prop_ordinalizeSamePrefix n = show n == take (length $ show n) (ordinalize n)
diff --git a/test/Text/Inflections/Tests.hs b/test/Text/Inflections/Tests.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/Inflections/Tests.hs
@@ -0,0 +1,104 @@
+module Text.Inflections.Tests where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.QuickCheck
+
+import Test.Framework (Test, testGroup)
+
+import Data.List (group)
+import Data.Char (toLower)
+
+import Text.Inflections
+import Text.Inflections.Parse.Types (Word(..))
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [testGroup "dasherize"
+         [ testCase "foo bar -> foo-bar" test_dasherize1
+         ],
+
+         testGroup "transliterate"
+         [ testCase "Without substitutions" test_correctTransliterationWithoutSubs
+         , testCase "With substitutions" test_correctTransliterationWithSubs
+         , testCase "Missing subs" test_correctTransliterationMissingSubs
+         ],
+
+         testGroup "parameterize"
+         [ testProperty "Contains only valid chars"
+                        prop_parameterize1
+         , testProperty "Does not begin with a separator character"
+                         prop_parameterize2
+         , testProperty "Does not end in a separator character"
+                         prop_parameterize3
+         , testProperty "All alphanumerics in input exist in output"
+                        prop_parameterize4
+         , testProperty "Doesn't have subsequences of more than one hyphen"
+                        prop_parameterize5
+         ]
+        ]
+
+
+test_correctTransliterationWithoutSubs =
+    transliterate "this is a test" @?= "this is a test"
+
+test_correctTransliterationWithSubs =
+    transliterate "Feliz año nuevo" @?= "Feliz ano nuevo"
+
+test_correctTransliterationMissingSubs =
+    transliterate "Have a ❤ ñ!" @?= "Have a ? n!"
+
+fromRight :: Either a b -> b
+fromRight (Left _)  =
+    error "Either.Unwrap.fromRight: Argument takes form 'Left _'"
+fromRight (Right x) = x
+
+isRight :: Either a b -> Bool
+isRight (Left _)  = False
+isRight (Right _) = True
+
+
+test_dasherize1 = "foo-bar" @?= dasherize [Word "foo", Word "bar"]
+
+prop_parameterize1 :: String -> Bool
+prop_parameterize1 sf = all (`elem` (alphaNumerics ++ "-_")) $
+                        parameterize sf
+
+prop_parameterize2 :: String -> Property
+prop_parameterize2 s =
+    (not . null) parameterized ==> head parameterized /= '-'
+    where parameterized = parameterize s
+
+prop_parameterize3 :: String -> Property
+prop_parameterize3 s =
+    (not . null) parameterized ==> last parameterized /= '-'
+    where parameterized = parameterize s
+
+prop_parameterize4 :: String -> Bool
+prop_parameterize4 s = all (\c -> c `notElem` alphaNumerics ||
+                              c `elem` (alphaNumerics ++ "-") &&
+                              c `elem` parameterized) $ map toLower s
+    where parameterized = parameterize s
+
+prop_parameterize5 :: String -> Bool
+prop_parameterize5 s = longestSequenceOf '-' parameterized <= 1
+    where parameterized = parameterize s
+
+
+-- Helper functions and shared tests
+
+longestSequenceOf :: Char -> String -> Int
+longestSequenceOf c [] = 0
+longestSequenceOf c s =
+    if null subseqLengths then 0 else maximum subseqLengths
+
+  where subseqLengths = (map length . filter (\str -> head str == c) . group) s
+
+numMatching char str = length $ filter (== char) str
+
+alphaNumerics :: String
+alphaNumerics = ['a'..'z'] ++ ['0'..'9']
diff --git a/test/Text/Inflections/TitleizeTest.hs b/test/Text/Inflections/TitleizeTest.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/Inflections/TitleizeTest.hs
@@ -0,0 +1,25 @@
+module Text.Inflections.TitleizeTest where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.Framework (Test, testGroup)
+
+import Text.Inflections (titleize)
+import Text.Inflections.Parse.Types (Word(..))
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [ testGroup "titleize"
+          [ testCase "employee_salary -> Employee Salary" test_titleize1
+          , testCase "underground -> Underground" test_titleize2
+          ]
+        ]
+
+----------------------------------------------------
+
+test_titleize1 = "Employee Salary" @?=
+                 titleize [Word "Employee", Word "Salary"]
+test_titleize2 = "Underground" @?= titleize [Word "underground"]
diff --git a/test/Text/Inflections/UnderscoreTest.hs b/test/Text/Inflections/UnderscoreTest.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/Inflections/UnderscoreTest.hs
@@ -0,0 +1,20 @@
+module Text.Inflections.UnderscoreTest where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.Framework (Test, testGroup)
+
+import Text.Inflections (underscore)
+import Text.Inflections.Parse.Types (Word(..))
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [testGroup "underscore"
+          [ testCase "testThis -> test_this" test_underscore
+          ]
+        ]
+
+test_underscore = "test_this" @?= underscore [Word "test", Word "this"]
diff --git a/test/Text/InflectionsTest.hs b/test/Text/InflectionsTest.hs
new file mode 100644
--- /dev/null
+++ b/test/Text/InflectionsTest.hs
@@ -0,0 +1,27 @@
+module Text.InflectionsTest where
+
+import Test.HUnit hiding (Test)
+
+import Test.Framework.Providers.HUnit (testCase)
+
+import Test.Framework (Test, testGroup)
+
+import Text.Inflections (toUnderscore, toDashed, toCamelCased)
+
+{-# ANN module "HLint: ignore Use camelCase" #-}
+
+tests :: [Test]
+tests = [ testGroup "toUnderscore"
+          [ testCase "camelCasedText -> camel_cased_text" test_to_underscore
+          ]
+        , testGroup "toDashed"
+          [ testCase "camelCasedText -> camel-cased-text" test_to_dashed
+          ]
+        , testGroup "toCamelCased"
+          [ testCase "underscored_text -> camelCasedText" test_to_camel_cased
+          ]
+        ]
+
+test_to_underscore = "camel_cased_text" @?= toUnderscore "camelCasedText"
+test_to_dashed = "camel-cased-text" @?= toDashed "camelCasedText"
+test_to_camel_cased = "underscoredText" @?= toCamelCased False "underscored_text"