diff --git a/hw-succinct.cabal b/hw-succinct.cabal
--- a/hw-succinct.cabal
+++ b/hw-succinct.cabal
@@ -1,5 +1,5 @@
 name:                   hw-succinct
-version:                0.0.0.10
+version:                0.0.0.11
 synopsis:               Conduits for tokenizing streams.
 description:            Please see README.md
 homepage:               http://github.com/haskell-works/hw-succinct#readme
@@ -36,8 +36,7 @@
 library
   hs-source-dirs:       src
   exposed-modules:      HaskellWorks.Data.Attoparsec.Final.Parser
-                      , HaskellWorks.Data.Json.Final.Tokenize
-                      , HaskellWorks.Data.Json.Final.Tokenize.Internal
+                      , HaskellWorks.Data.Json
                       , HaskellWorks.Data.Json.Succinct
                       , HaskellWorks.Data.Json.Succinct.Cursor
                       , HaskellWorks.Data.Json.Succinct.Cursor.BalancedParens
@@ -45,6 +44,9 @@
                       , HaskellWorks.Data.Json.Succinct.Cursor.CursorType
                       , HaskellWorks.Data.Json.Succinct.Cursor.InterestBits
                       , HaskellWorks.Data.Json.Succinct.Cursor.Internal
+                      , HaskellWorks.Data.Json.Succinct.Cursor.Token
+                      , HaskellWorks.Data.Json.Token.Tokenize
+                      , HaskellWorks.Data.Json.Token.Types
                       , HaskellWorks.Data.Json.Token
                       , HaskellWorks.Data.Succinct
   build-depends:        base                            >= 4.7  && < 5
@@ -66,7 +68,7 @@
   type:                 exitcode-stdio-1.0
   hs-source-dirs:       test
   main-is:              Spec.hs
-  other-modules:        HaskellWorks.Data.Json.Final.TokenizeSpec
+  other-modules:        HaskellWorks.Data.Json.Token.TokenizeSpec
                       , HaskellWorks.Data.Json.Succinct.CursorSpec
                       , HaskellWorks.Data.Json.Succinct.Cursor.InterestBitsSpec
   build-depends:        base
diff --git a/src/HaskellWorks/Data/Json.hs b/src/HaskellWorks/Data/Json.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Json.hs
@@ -0,0 +1,11 @@
+-- |
+-- Copyright: 2016 John Ky
+-- License: MIT
+--
+-- Json
+module HaskellWorks.Data.Json
+    ( module X
+    ) where
+
+import           HaskellWorks.Data.Json.Succinct  as X
+import           HaskellWorks.Data.Json.Token     as X
diff --git a/src/HaskellWorks/Data/Json/Final/Tokenize.hs b/src/HaskellWorks/Data/Json/Final/Tokenize.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Json/Final/Tokenize.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module HaskellWorks.Data.Json.Final.Tokenize
-    ( parseJsonToken
-    ) where
-
-import           HaskellWorks.Data.Json.Final.Tokenize.Internal
diff --git a/src/HaskellWorks/Data/Json/Final/Tokenize/Internal.hs b/src/HaskellWorks/Data/Json/Final/Tokenize/Internal.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Json/Final/Tokenize/Internal.hs
+++ /dev/null
@@ -1,122 +0,0 @@
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module HaskellWorks.Data.Json.Final.Tokenize.Internal
-    ( IsChar(..)
-    , JsonToken(..)
-    , AFP.Parser(..)
-    , parseJsonToken
-    , parseJsonTokenString
-    , escapedChar
-    ) where
-
-import           Control.Applicative
-import           Control.Monad
-import qualified Data.Attoparsec.ByteString.Char8          as BC
-import qualified Data.Attoparsec.Combinator                as AC
-import qualified Data.Attoparsec.Types                     as T
-import           Data.Bits
-import           Data.Char
-import           Data.String
-import           HaskellWorks.Data.Attoparsec.Final.Parser as AFP
-import           HaskellWorks.Data.Char.IsChar
-import           HaskellWorks.Data.Json.Token
-
-hexDigitNumeric :: AFP.Parser t => T.Parser t Int
-hexDigitNumeric = do
-  c <- satisfyChar (\c -> '0' <= c && c <= '9')
-  return $ ord c - ord '0'
-
-hexDigitAlphaLower :: AFP.Parser t => T.Parser t Int
-hexDigitAlphaLower = do
-  c <- satisfyChar (\c -> 'a' <= c && c <= 'z')
-  return $ ord c - ord 'a' + 10
-
-hexDigitAlphaUpper :: AFP.Parser t => T.Parser t Int
-hexDigitAlphaUpper = do
-  c <- satisfyChar (\c -> 'A' <= c && c <= 'Z')
-  return $ ord c - ord 'A' + 10
-
-hexDigit :: AFP.Parser t => T.Parser t Int
-hexDigit = hexDigitNumeric <|> hexDigitAlphaLower <|> hexDigitAlphaUpper
-
-verbatimChar :: AFP.Parser t => T.Parser t Char
-verbatimChar  = satisfyChar (BC.notInClass "\"\\") <?> "invalid string character"
-
-escapedChar :: (IsString t, AFP.Parser t) => T.Parser t Char
-escapedChar   = do
-  _ <- string "\\"
-  (   char '"'  >> return '"'  ) <|>
-    ( char 'b'  >> return '\b' ) <|>
-    ( char 'n'  >> return '\n' ) <|>
-    ( char 'f'  >> return '\f' ) <|>
-    ( char 'r'  >> return '\r' ) <|>
-    ( char 't'  >> return '\t' ) <|>
-    ( char '\\' >> return '\\' ) <|>
-    ( char '\'' >> return '\'' ) <|>
-    ( char '/'  >> return '/'  )
-
-escapedCode :: (IsString t, AFP.Parser t) => T.Parser t Char
-escapedCode   = do
-  _ <- string "\\u"
-  a <- hexDigit
-  b <- hexDigit
-  c <- hexDigit
-  d <- hexDigit
-  return $ chr $ a `shift` 24 .|. b `shift` 16 .|. c `shift` 8 .|. d
-
-parseJsonTokenString :: (JsonTokenLike j, AFP.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j
-parseJsonTokenString = do
-  _ <- string "\""
-  value <- many (verbatimChar <|> escapedChar <|> escapedCode)
-  _ <- string "\""
-  return $ jsonTokenString value
-
-parseJsonTokenBraceL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenBraceL = string "{" >> return jsonTokenBraceL
-
-parseJsonTokenBraceR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenBraceR = string "}" >> return jsonTokenBraceR
-
-parseJsonTokenBracketL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenBracketL = string "[" >> return jsonTokenBracketL
-
-parseJsonTokenBracketR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenBracketR = string "]" >> return jsonTokenBracketR
-
-parseJsonTokenComma :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenComma = string "," >> return jsonTokenComma
-
-parseJsonTokenColon :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenColon = string ":" >> return jsonTokenColon
-
-parseJsonTokenWhitespace :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenWhitespace = do
-  _ <- AC.many1' $ BC.choice [string " ", string "\t", string "\n", string "\r"]
-  return jsonTokenWhitespace
-
-parseJsonTokenNull :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenNull = string "null" >> return jsonTokenNull
-
-parseJsonTokenBoolean :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenBoolean = true <|> false
-  where
-    true  = string "true"   >> return (jsonTokenBoolean True)
-    false = string "false"  >> return (jsonTokenBoolean False)
-
-parseJsonTokenDouble :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonTokenDouble = liftM jsonTokenNumber rational
-
-parseJsonToken :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
-parseJsonToken =
-  parseJsonTokenString     <|>
-  parseJsonTokenBraceL     <|>
-  parseJsonTokenBraceR     <|>
-  parseJsonTokenBracketL   <|>
-  parseJsonTokenBracketR   <|>
-  parseJsonTokenComma      <|>
-  parseJsonTokenColon      <|>
-  parseJsonTokenWhitespace <|>
-  parseJsonTokenNull       <|>
-  parseJsonTokenBoolean    <|>
-  parseJsonTokenDouble
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
@@ -1,28 +1,8 @@
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE InstanceSigs          #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 
 module HaskellWorks.Data.Json.Succinct.Cursor
   ( module X
-  , jsonTokenAt
   ) where
 
-import qualified Data.Attoparsec.ByteString.Char8                           as ABC
-import           Data.ByteString.Internal                                   as BSI
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Json.Final.Tokenize.Internal
 import           HaskellWorks.Data.Json.Succinct.Cursor.CursorType          as X
 import           HaskellWorks.Data.Json.Succinct.Cursor.Internal            as X
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Rank1
-import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Select1
-import           HaskellWorks.Data.Vector.VectorLike
-
-jsonTokenAt :: (Rank1 w, Select1 v, TestBit w) => JsonCursor ByteString v w -> Maybe JsonToken
-jsonTokenAt k = if balancedParens k .?. lastPositionOf (cursorRank k)
-  then case ABC.parse parseJsonToken (vDrop (toCount (jsonCursorPos k)) (cursorText k)) of
-    ABC.Fail    {}  -> error "Failed to parse token in cursor"
-    ABC.Partial _   -> error "Failed to parse token in cursor"
-    ABC.Done    _ r -> Just r
-  else Nothing
+import           HaskellWorks.Data.Json.Succinct.Cursor.Token               as X
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs
@@ -0,0 +1,23 @@
+
+module HaskellWorks.Data.Json.Succinct.Cursor.Token
+  ( jsonTokenAt
+  ) where
+
+import qualified Data.Attoparsec.ByteString.Char8                           as ABC
+import           Data.ByteString.Internal                                   as BSI
+import           HaskellWorks.Data.Bits.BitWise
+import           HaskellWorks.Data.Json.Succinct.Cursor.CursorType
+import           HaskellWorks.Data.Json.Succinct.Cursor.Internal
+import           HaskellWorks.Data.Json.Token.Tokenize
+import           HaskellWorks.Data.Positioning
+import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Rank1
+import           HaskellWorks.Data.Succinct.RankSelect.Binary.Basic.Select1
+import           HaskellWorks.Data.Vector.VectorLike
+
+jsonTokenAt :: (Rank1 w, Select1 v, TestBit w) => JsonCursor ByteString v w -> Maybe JsonToken
+jsonTokenAt k = if balancedParens k .?. lastPositionOf (cursorRank k)
+  then case ABC.parse parseJsonToken (vDrop (toCount (jsonCursorPos k)) (cursorText k)) of
+    ABC.Fail    {}  -> error "Failed to parse token in cursor"
+    ABC.Partial _   -> error "Failed to parse token in cursor"
+    ABC.Done    _ r -> Just r
+  else Nothing
diff --git a/src/HaskellWorks/Data/Json/Token.hs b/src/HaskellWorks/Data/Json/Token.hs
--- a/src/HaskellWorks/Data/Json/Token.hs
+++ b/src/HaskellWorks/Data/Json/Token.hs
@@ -1,41 +1,6 @@
-module HaskellWorks.Data.Json.Token (JsonToken(..), JsonTokenLike(..)) where
-
-class JsonTokenLike j where
-  jsonTokenBraceL     :: j
-  jsonTokenBraceR     :: j
-  jsonTokenBracketL   :: j
-  jsonTokenBracketR   :: j
-  jsonTokenComma      :: j
-  jsonTokenColon      :: j
-  jsonTokenWhitespace :: j
-  jsonTokenString     :: String -> j
-  jsonTokenBoolean    :: Bool -> j
-  jsonTokenNumber     :: Double -> j
-  jsonTokenNull       :: j
-
-data JsonToken
-  = JsonTokenBraceL
-  | JsonTokenBraceR
-  | JsonTokenBracketL
-  | JsonTokenBracketR
-  | JsonTokenComma
-  | JsonTokenColon
-  | JsonTokenWhitespace
-  | JsonTokenString String
-  | JsonTokenBoolean Bool
-  | JsonTokenNumber Double
-  | JsonTokenNull
-  deriving (Eq, Show)
+module HaskellWorks.Data.Json.Token
+  ( module X
+  ) where
 
-instance JsonTokenLike JsonToken where
-  jsonTokenBraceL     = JsonTokenBraceL
-  jsonTokenBraceR     = JsonTokenBraceR
-  jsonTokenBracketL   = JsonTokenBracketL
-  jsonTokenBracketR   = JsonTokenBracketR
-  jsonTokenComma      = JsonTokenComma
-  jsonTokenColon      = JsonTokenColon
-  jsonTokenWhitespace = JsonTokenWhitespace
-  jsonTokenString     = JsonTokenString
-  jsonTokenBoolean    = JsonTokenBoolean
-  jsonTokenNumber     = JsonTokenNumber
-  jsonTokenNull       = JsonTokenNull
+  import           HaskellWorks.Data.Json.Token.Types as X
+  import           HaskellWorks.Data.Json.Token.Tokenize as X
diff --git a/src/HaskellWorks/Data/Json/Token/Tokenize.hs b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
@@ -0,0 +1,122 @@
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module HaskellWorks.Data.Json.Token.Tokenize
+    ( IsChar(..)
+    , JsonToken(..)
+    , AFP.Parser(..)
+    , parseJsonToken
+    , parseJsonTokenString
+    , escapedChar
+    ) where
+
+import           Control.Applicative
+import           Control.Monad
+import qualified Data.Attoparsec.ByteString.Char8          as BC
+import qualified Data.Attoparsec.Combinator                as AC
+import qualified Data.Attoparsec.Types                     as T
+import           Data.Bits
+import           Data.Char
+import           Data.String
+import           HaskellWorks.Data.Attoparsec.Final.Parser as AFP
+import           HaskellWorks.Data.Char.IsChar
+import           HaskellWorks.Data.Json.Token.Types
+
+hexDigitNumeric :: AFP.Parser t => T.Parser t Int
+hexDigitNumeric = do
+  c <- satisfyChar (\c -> '0' <= c && c <= '9')
+  return $ ord c - ord '0'
+
+hexDigitAlphaLower :: AFP.Parser t => T.Parser t Int
+hexDigitAlphaLower = do
+  c <- satisfyChar (\c -> 'a' <= c && c <= 'z')
+  return $ ord c - ord 'a' + 10
+
+hexDigitAlphaUpper :: AFP.Parser t => T.Parser t Int
+hexDigitAlphaUpper = do
+  c <- satisfyChar (\c -> 'A' <= c && c <= 'Z')
+  return $ ord c - ord 'A' + 10
+
+hexDigit :: AFP.Parser t => T.Parser t Int
+hexDigit = hexDigitNumeric <|> hexDigitAlphaLower <|> hexDigitAlphaUpper
+
+verbatimChar :: AFP.Parser t => T.Parser t Char
+verbatimChar  = satisfyChar (BC.notInClass "\"\\") <?> "invalid string character"
+
+escapedChar :: (IsString t, AFP.Parser t) => T.Parser t Char
+escapedChar   = do
+  _ <- string "\\"
+  (   char '"'  >> return '"'  ) <|>
+    ( char 'b'  >> return '\b' ) <|>
+    ( char 'n'  >> return '\n' ) <|>
+    ( char 'f'  >> return '\f' ) <|>
+    ( char 'r'  >> return '\r' ) <|>
+    ( char 't'  >> return '\t' ) <|>
+    ( char '\\' >> return '\\' ) <|>
+    ( char '\'' >> return '\'' ) <|>
+    ( char '/'  >> return '/'  )
+
+escapedCode :: (IsString t, AFP.Parser t) => T.Parser t Char
+escapedCode   = do
+  _ <- string "\\u"
+  a <- hexDigit
+  b <- hexDigit
+  c <- hexDigit
+  d <- hexDigit
+  return $ chr $ a `shift` 24 .|. b `shift` 16 .|. c `shift` 8 .|. d
+
+parseJsonTokenString :: (JsonTokenLike j, AFP.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j
+parseJsonTokenString = do
+  _ <- string "\""
+  value <- many (verbatimChar <|> escapedChar <|> escapedCode)
+  _ <- string "\""
+  return $ jsonTokenString value
+
+parseJsonTokenBraceL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBraceL = string "{" >> return jsonTokenBraceL
+
+parseJsonTokenBraceR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBraceR = string "}" >> return jsonTokenBraceR
+
+parseJsonTokenBracketL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBracketL = string "[" >> return jsonTokenBracketL
+
+parseJsonTokenBracketR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBracketR = string "]" >> return jsonTokenBracketR
+
+parseJsonTokenComma :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenComma = string "," >> return jsonTokenComma
+
+parseJsonTokenColon :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenColon = string ":" >> return jsonTokenColon
+
+parseJsonTokenWhitespace :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenWhitespace = do
+  _ <- AC.many1' $ BC.choice [string " ", string "\t", string "\n", string "\r"]
+  return jsonTokenWhitespace
+
+parseJsonTokenNull :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenNull = string "null" >> return jsonTokenNull
+
+parseJsonTokenBoolean :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBoolean = true <|> false
+  where
+    true  = string "true"   >> return (jsonTokenBoolean True)
+    false = string "false"  >> return (jsonTokenBoolean False)
+
+parseJsonTokenDouble :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenDouble = liftM jsonTokenNumber rational
+
+parseJsonToken :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonToken =
+  parseJsonTokenString     <|>
+  parseJsonTokenBraceL     <|>
+  parseJsonTokenBraceR     <|>
+  parseJsonTokenBracketL   <|>
+  parseJsonTokenBracketR   <|>
+  parseJsonTokenComma      <|>
+  parseJsonTokenColon      <|>
+  parseJsonTokenWhitespace <|>
+  parseJsonTokenNull       <|>
+  parseJsonTokenBoolean    <|>
+  parseJsonTokenDouble
diff --git a/src/HaskellWorks/Data/Json/Token/Types.hs b/src/HaskellWorks/Data/Json/Token/Types.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Json/Token/Types.hs
@@ -0,0 +1,41 @@
+module HaskellWorks.Data.Json.Token.Types (JsonToken(..), JsonTokenLike(..)) where
+
+class JsonTokenLike j where
+  jsonTokenBraceL     :: j
+  jsonTokenBraceR     :: j
+  jsonTokenBracketL   :: j
+  jsonTokenBracketR   :: j
+  jsonTokenComma      :: j
+  jsonTokenColon      :: j
+  jsonTokenWhitespace :: j
+  jsonTokenString     :: String -> j
+  jsonTokenBoolean    :: Bool -> j
+  jsonTokenNumber     :: Double -> j
+  jsonTokenNull       :: j
+
+data JsonToken
+  = JsonTokenBraceL
+  | JsonTokenBraceR
+  | JsonTokenBracketL
+  | JsonTokenBracketR
+  | JsonTokenComma
+  | JsonTokenColon
+  | JsonTokenWhitespace
+  | JsonTokenString String
+  | JsonTokenBoolean Bool
+  | JsonTokenNumber Double
+  | JsonTokenNull
+  deriving (Eq, Show)
+
+instance JsonTokenLike JsonToken where
+  jsonTokenBraceL     = JsonTokenBraceL
+  jsonTokenBraceR     = JsonTokenBraceR
+  jsonTokenBracketL   = JsonTokenBracketL
+  jsonTokenBracketR   = JsonTokenBracketR
+  jsonTokenComma      = JsonTokenComma
+  jsonTokenColon      = JsonTokenColon
+  jsonTokenWhitespace = JsonTokenWhitespace
+  jsonTokenString     = JsonTokenString
+  jsonTokenBoolean    = JsonTokenBoolean
+  jsonTokenNumber     = JsonTokenNumber
+  jsonTokenNull       = JsonTokenNull
diff --git a/test/HaskellWorks/Data/Json/Final/TokenizeSpec.hs b/test/HaskellWorks/Data/Json/Final/TokenizeSpec.hs
deleted file mode 100644
--- a/test/HaskellWorks/Data/Json/Final/TokenizeSpec.hs
+++ /dev/null
@@ -1,50 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
-module HaskellWorks.Data.Json.Final.TokenizeSpec (spec) where
-
-import qualified Data.Attoparsec.ByteString.Char8      as BC
-import           Data.ByteString                       as BS
-import           HaskellWorks.Data.Json.Final.Tokenize
-import           HaskellWorks.Data.Json.Token
-import           Test.Hspec
-
-{-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
-
-parseJsonToken' :: ByteString -> Either String JsonToken
-parseJsonToken' = BC.parseOnly parseJsonToken
-
-spec :: Spec
-spec = describe "Data.Conduit.Succinct.JsonSpec" $ do
-  describe "When parsing single token at beginning of text" $ do
-    it "Empty Json should produce no bits" $
-      parseJsonToken' "" `shouldBe` Left "not enough input"
-    it "Json with one space should produce whitespace token" $
-      parseJsonToken' " " `shouldBe` Right JsonTokenWhitespace
-    it "Json with two spaces should produce whitespace token" $
-      parseJsonToken' "  " `shouldBe` Right JsonTokenWhitespace
-    it "Spaces and newlines should produce no bits" $
-      parseJsonToken' "  \n \r \t " `shouldBe` Right JsonTokenWhitespace
-    it "`null` at beginning should produce one bit" $
-      parseJsonToken' "null " `shouldBe` Right JsonTokenNull
-    it "number at beginning should produce one bit" $
-      parseJsonToken' "1234 " `shouldBe` Right (JsonTokenNumber 1234)
-    it "false at beginning should produce one bit" $
-      parseJsonToken' "false " `shouldBe` Right (JsonTokenBoolean False)
-    it "true at beginning should produce one bit" $
-      parseJsonToken' "true " `shouldBe` Right (JsonTokenBoolean True)
-    it "string at beginning should produce one bit" $
-      parseJsonToken' "\"hello\" " `shouldBe` Right (JsonTokenString "hello")
-    it "quoted string should parse" $
-      parseJsonToken' "\"\\\"\" " `shouldBe` Right (JsonTokenString "\"")
-    it "left brace at beginning should produce one bit" $
-      parseJsonToken' "{ " `shouldBe` Right JsonTokenBraceL
-    it "right brace at beginning should produce one bit" $
-      parseJsonToken' "} " `shouldBe` Right JsonTokenBraceR
-    it "left bracket at beginning should produce one bit" $
-      parseJsonToken' "[ " `shouldBe` Right JsonTokenBracketL
-    it "right bracket at beginning should produce one bit" $
-      parseJsonToken' "] " `shouldBe` Right JsonTokenBracketR
-    it "right bracket at beginning should produce one bit" $
-      parseJsonToken' ": " `shouldBe` Right JsonTokenColon
-    it "right bracket at beginning should produce one bit" $
-      parseJsonToken' ", " `shouldBe` Right JsonTokenComma
diff --git a/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs b/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs
@@ -0,0 +1,49 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HaskellWorks.Data.Json.Token.TokenizeSpec (spec) where
+
+import qualified Data.Attoparsec.ByteString.Char8      as BC
+import           Data.ByteString                       as BS
+import           HaskellWorks.Data.Json.Token.Tokenize
+import           Test.Hspec
+
+{-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
+
+parseJsonToken' :: ByteString -> Either String JsonToken
+parseJsonToken' = BC.parseOnly parseJsonToken
+
+spec :: Spec
+spec = describe "Data.Conduit.Succinct.JsonSpec" $ do
+  describe "When parsing single token at beginning of text" $ do
+    it "Empty Json should produce no bits" $
+      parseJsonToken' "" `shouldBe` Left "not enough input"
+    it "Json with one space should produce whitespace token" $
+      parseJsonToken' " " `shouldBe` Right JsonTokenWhitespace
+    it "Json with two spaces should produce whitespace token" $
+      parseJsonToken' "  " `shouldBe` Right JsonTokenWhitespace
+    it "Spaces and newlines should produce no bits" $
+      parseJsonToken' "  \n \r \t " `shouldBe` Right JsonTokenWhitespace
+    it "`null` at beginning should produce one bit" $
+      parseJsonToken' "null " `shouldBe` Right JsonTokenNull
+    it "number at beginning should produce one bit" $
+      parseJsonToken' "1234 " `shouldBe` Right (JsonTokenNumber 1234)
+    it "false at beginning should produce one bit" $
+      parseJsonToken' "false " `shouldBe` Right (JsonTokenBoolean False)
+    it "true at beginning should produce one bit" $
+      parseJsonToken' "true " `shouldBe` Right (JsonTokenBoolean True)
+    it "string at beginning should produce one bit" $
+      parseJsonToken' "\"hello\" " `shouldBe` Right (JsonTokenString "hello")
+    it "quoted string should parse" $
+      parseJsonToken' "\"\\\"\" " `shouldBe` Right (JsonTokenString "\"")
+    it "left brace at beginning should produce one bit" $
+      parseJsonToken' "{ " `shouldBe` Right JsonTokenBraceL
+    it "right brace at beginning should produce one bit" $
+      parseJsonToken' "} " `shouldBe` Right JsonTokenBraceR
+    it "left bracket at beginning should produce one bit" $
+      parseJsonToken' "[ " `shouldBe` Right JsonTokenBracketL
+    it "right bracket at beginning should produce one bit" $
+      parseJsonToken' "] " `shouldBe` Right JsonTokenBracketR
+    it "right bracket at beginning should produce one bit" $
+      parseJsonToken' ": " `shouldBe` Right JsonTokenColon
+    it "right bracket at beginning should produce one bit" $
+      parseJsonToken' ", " `shouldBe` Right JsonTokenComma