diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,12 @@
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## 1.0.0.2 - 2025-10-24
+
+### Changed
+
+- Split the test code into ordinary test and code generation test. The code generation test will not be run by default (by Hackage or Stackage, for example).
+
 ## 1.0.0.1 - 2025-10-24
 
 ### Changed
diff --git a/codegen/Main.hs b/codegen/Main.hs
new file mode 100644
--- /dev/null
+++ b/codegen/Main.hs
@@ -0,0 +1,229 @@
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module Main (main) where
+
+import Control.Exception
+import Control.Monad (unless)
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as B
+import Data.ByteString.Builder (Builder)
+import qualified Data.ByteString.Builder as B
+import Data.List (intercalate, intersperse)
+import Data.Maybe (fromMaybe)
+import RawFilePath
+import System.Exit
+import System.IO
+import System.Posix.Env.ByteString
+import System.Posix.Temp.ByteString
+
+data StringType
+  = String
+  | StrictByteString
+  | LazyByteString
+  | ByteStringBuilder
+  | ShortByteString
+  | StrictText
+  | LazyText
+  | TextBuilder
+  deriving (Eq, Show)
+
+stringTypeName :: StringType -> Builder
+stringTypeName = \case
+  String -> "String"
+  StrictByteString -> "B.ByteString"
+  LazyByteString -> "LB.ByteString"
+  ByteStringBuilder -> "BB.Builder"
+  ShortByteString -> "SB.ShortByteString"
+  StrictText -> "T.Text"
+  LazyText -> "LT.Text"
+  TextBuilder -> "TB.Builder"
+
+data Strategy
+  = ConvFunc ByteString
+  | Via StringType
+
+type Row = (StringType, StringType, Strategy)
+
+mappings :: [Row]
+mappings =
+  [ (String, StrictByteString, Via StrictText)
+  , (String, LazyByteString, Via LazyText)
+  , (String, ByteStringBuilder, ConvFunc "BB.stringUtf8")
+  , (String, ShortByteString, Via StrictByteString)
+  , (String, StrictText, ConvFunc "T.pack")
+  , (String, LazyText, ConvFunc "LT.pack")
+  , (String, TextBuilder, ConvFunc "TB.fromString")
+  , (StrictByteString, String, Via StrictText)
+  , (StrictByteString, LazyByteString, ConvFunc "LB.fromStrict")
+  , (StrictByteString, ByteStringBuilder, ConvFunc "BB.byteString")
+  , (StrictByteString, ShortByteString, ConvFunc "SB.toShort")
+  , (StrictByteString, StrictText, ConvFunc "TE.decodeUtf8Lenient")
+  , (StrictByteString, LazyText, Via LazyByteString)
+  , (StrictByteString, TextBuilder, Via StrictText)
+  , (LazyByteString, String, Via LazyText)
+  , (LazyByteString, StrictByteString, ConvFunc "LB.toStrict")
+  , (LazyByteString, ByteStringBuilder, ConvFunc "BB.lazyByteString")
+  , (LazyByteString, ShortByteString, Via StrictByteString)
+  , (LazyByteString, StrictText, Via StrictByteString)
+  , (LazyByteString, LazyText, ConvFunc "LTE.decodeUtf8With TEE.lenientDecode")
+  , (LazyByteString, TextBuilder, Via LazyText)
+  , (ByteStringBuilder, String, Via LazyText)
+  , (ByteStringBuilder, StrictByteString, Via LazyByteString)
+  , (ByteStringBuilder, LazyByteString, ConvFunc "BB.toLazyByteString")
+  , (ByteStringBuilder, ShortByteString, Via StrictByteString)
+  , (ByteStringBuilder, StrictText, Via StrictByteString)
+  , (ByteStringBuilder, LazyText, Via LazyByteString)
+  , (ByteStringBuilder, TextBuilder, Via LazyByteString)
+  , (ShortByteString, String, Via StrictByteString)
+  , (ShortByteString, StrictByteString, ConvFunc "SB.fromShort")
+  , (ShortByteString, LazyByteString, Via StrictByteString)
+  , (ShortByteString, ByteStringBuilder, ConvFunc "BB.shortByteString")
+  , (ShortByteString, StrictText, Via StrictByteString)
+  , (ShortByteString, LazyText, Via StrictByteString)
+  , (ShortByteString, TextBuilder, Via StrictByteString)
+  , (StrictText, String, ConvFunc "T.unpack")
+  , (StrictText, StrictByteString, ConvFunc "TE.encodeUtf8")
+  , (StrictText, LazyByteString, Via LazyText)
+  , (StrictText, ByteStringBuilder, ConvFunc "TE.encodeUtf8Builder")
+  , (StrictText, ShortByteString, Via StrictByteString)
+  , (StrictText, LazyText, ConvFunc "LT.fromStrict")
+  , (StrictText, TextBuilder, ConvFunc "TB.fromText")
+  , (LazyText, String, ConvFunc "LT.unpack")
+  , (LazyText, StrictByteString, Via LazyByteString)
+  , (LazyText, LazyByteString, ConvFunc "LTE.encodeUtf8")
+  , (LazyText, ByteStringBuilder, ConvFunc "LTE.encodeUtf8Builder")
+  , (LazyText, ShortByteString, Via StrictByteString)
+  , (LazyText, StrictText, ConvFunc "LT.toStrict")
+  , (LazyText, TextBuilder, ConvFunc "TB.fromLazyText")
+  , (TextBuilder, String, Via LazyText)
+  , (TextBuilder, StrictByteString, Via LazyText)
+  , (TextBuilder, LazyByteString, Via LazyText)
+  , (TextBuilder, ByteStringBuilder, Via LazyText)
+  , (TextBuilder, ShortByteString, Via LazyText)
+  , (TextBuilder, StrictText, Via LazyText)
+  , (TextBuilder, LazyText, ConvFunc "TB.toLazyText")
+  ]
+
+fullyQualifiedModule :: ByteString -> ByteString
+fullyQualifiedModule = \case
+  "B" -> "Data.ByteString"
+  "BB" -> "Data.ByteString.Builder"
+  "LB" -> "Data.ByteString.Lazy"
+  "SB" -> "Data.ByteString.Short"
+  "T" -> "Data.Text"
+  "TE" -> "Data.Text.Encoding"
+  "TEE" -> "Data.Text.Encoding.Error"
+  "LT" -> "Data.Text.Lazy"
+  "TB" -> "Data.Text.Lazy.Builder"
+  "LTE" -> "Data.Text.Lazy.Encoding"
+  unknown -> error $ show unknown <> " is not a correct module name"
+
+fullyQualifiedExpr :: ByteString -> ByteString
+fullyQualifiedExpr expr = fullyQualifiedModule moduleName <> rest
+ where
+  (moduleName, rest) = B.break (0x2e ==) expr
+
+forceLookup :: (Show k, Eq k) => k -> [(k, v)] -> v
+forceLookup key table = fromMaybe (error $ "key " <> show key <> " not found") $ lookup key table
+
+getStrategy
+  :: StringType -> StringType -> [Row] -> Strategy
+getStrategy fromType toType table = forceLookup (fromType, toType) kvTable
+ where
+  kvTable = flip map table $ \(a, b, c) -> ((a, b), c)
+
+getMapping
+  :: Row -> [Row] -> [ByteString]
+getMapping (fromType, toType, strategy) table = case strategy of
+  ConvFunc expr -> [expr]
+  Via intermediate ->
+    let formerStrategy = getStrategy fromType intermediate table
+        formerPart = getMapping (fromType, intermediate, formerStrategy) table
+        latterStrategy = getStrategy intermediate toType table
+        latterPart = getMapping (intermediate, toType, latterStrategy) table
+     in latterPart ++ formerPart
+
+main :: IO ()
+main = do
+  args <- getArgs
+  let noDiff = "--no-diff" `elem` args
+      shouldKeepFile = noDiff || "--keep" `elem` args
+  bracket acquire (release shouldKeepFile) $ \(tmpPath, hdl) -> do
+    B.putStr $ tmpPath <> "\n"
+    B.hPutBuilder hdl $ header <> mconcat instancePart
+    hClose hdl
+
+    unless noDiff $ do
+      diffExitCode <- runDiff tmpPath
+      exitWith diffExitCode
+ where
+  acquire = mkstemps "haskell-from-" ".hs"
+  release shouldKeepFile (path, hdl)
+    | shouldKeepFile = hClose hdl
+    | otherwise = hClose hdl >> removeFile path
+
+  runDiff path =
+    runProcess
+      "diff"
+      ["-u", "--color=always", path, "src/From/String/AutoGen.hs"]
+
+  instanceLine fromType toType =
+    mconcat
+      [ "instance From "
+      , stringTypeName fromType
+      , " "
+      , stringTypeName toType
+      , " where\n"
+      ]
+  instancePart =
+    [ let exprs = getMapping row mappings
+          quote b = "'" <> b <> "'"
+       in mconcat
+            [ "\n"
+            , "-- | "
+            , mconcat
+                $ intersperse " "
+                $ map
+                  (quote . B.byteString)
+                $ intercalate ["."]
+                -- Split by space, to link each part in the expression
+                $ map (map fullyQualifiedExpr . B.split 0x20) exprs
+            , "\n"
+            , instanceLine fromType toType
+            , "  from = "
+            , mconcat
+                $ intersperse
+                  " . "
+                $ map
+                  B.byteString
+                  exprs
+            , "\n"
+            ]
+    | row@(fromType, toType, _) <- mappings
+    ]
+
+runProcess :: RawFilePath -> [ByteString] -> IO ExitCode
+runProcess cmd args = startProcess (proc cmd args) >>= waitForProcess
+
+header :: Builder
+header =
+  "{- FOURMOLU_DISABLE -}\n\
+  \{- Make sure you edit test/Main.hs -}\n\
+  \{-# LANGUAGE FlexibleInstances #-}\n\
+  \{-# LANGUAGE MultiParamTypeClasses #-}\n\
+  \{-# OPTIONS_GHC -Wno-orphans #-}\n\
+  \\n\
+  \module From.String.AutoGen () where\n\
+  \\n\
+  \import qualified Data.ByteString as B\n\
+  \import qualified Data.ByteString.Builder as BB\n\
+  \import qualified Data.ByteString.Lazy as LB\n\
+  \import qualified Data.ByteString.Short as SB\n\
+  \import qualified Data.Text as T\n\
+  \import qualified Data.Text.Encoding as TE\n\
+  \import qualified Data.Text.Encoding.Error as TEE\n\
+  \import qualified Data.Text.Lazy as LT\n\
+  \import qualified Data.Text.Lazy.Builder as TB\n\
+  \import qualified Data.Text.Lazy.Encoding as LTE\n\
+  \import From (From (..))\n"
diff --git a/from-string.cabal b/from-string.cabal
--- a/from-string.cabal
+++ b/from-string.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           from-string
-version:        1.0.0.1
+version:        1.0.0.2
 synopsis:       Instances of 'From' for common string types
 description:    Convenient "sane default" conversion from/to strict ByteString, lazy
                 ByteString, ByteString Builder, ShortByteString, strict Text, lazy Text, Text
@@ -28,6 +28,11 @@
   type: git
   location: https://codeberg.org/xt/from
 
+flag codegen
+  description: Enable code generation test
+  manual: True
+  default: False
+
 library
   exposed-modules:
       From.String
@@ -44,19 +49,39 @@
     , text >=2.0 && <3
   default-language: Haskell2010
 
-test-suite from-string-test
+test-suite codegen
   type: exitcode-stdio-1.0
   main-is: Main.hs
   other-modules:
       Paths_from_string
   hs-source-dirs:
+      codegen
+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints
+  build-depends:
+      base >=4.2 && <5
+    , bytestring >=0.11.4.0 && <2
+    , from >=1.0 && <2
+    , rawfilepath >=1.0.1 && <2
+    , text >=2.0 && <3
+    , unix >2.7.3 && <3
+  default-language: Haskell2010
+  if flag(codegen)
+    buildable: True
+  else
+    buildable: False
+
+test-suite test
+  type: exitcode-stdio-1.0
+  main-is: Main.hs
+  other-modules:
+      Paths_from_string
+  hs-source-dirs:
       test
   ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wmissing-export-lists -Wmissing-home-modules -Wpartial-fields -Wredundant-constraints
   build-depends:
       base >=4.2 && <5
-    , bytestring
+    , bytestring >=0.11.4.0 && <2
     , from >=1.0 && <2
-    , rawfilepath
+    , from-string
     , text >=2.0 && <3
-    , unix
   default-language: Haskell2010
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -1,229 +1,89 @@
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE OverloadedStrings #-}
-
 module Main (main) where
 
-import Control.Exception
-import Control.Monad (unless)
-import Data.ByteString (ByteString)
 import qualified Data.ByteString as B
-import Data.ByteString.Builder (Builder)
-import qualified Data.ByteString.Builder as B
-import Data.List (intercalate, intersperse)
-import Data.Maybe (fromMaybe)
-import RawFilePath
+import qualified Data.ByteString.Builder as BB
+import qualified Data.ByteString.Lazy as LB
+import qualified Data.ByteString.Short as SB
+import qualified Data.Text as T
+import qualified Data.Text.Lazy as LT
+import qualified Data.Text.Lazy.Builder as TB
+import From.String
 import System.Exit
-import System.IO
-import System.Posix.Env.ByteString
-import System.Posix.Temp.ByteString
 
-data StringType
-  = String
-  | StrictByteString
-  | LazyByteString
-  | ByteStringBuilder
-  | ShortByteString
-  | StrictText
-  | LazyText
-  | TextBuilder
-  deriving (Eq, Show)
-
-stringTypeName :: StringType -> Builder
-stringTypeName = \case
-  String -> "String"
-  StrictByteString -> "B.ByteString"
-  LazyByteString -> "LB.ByteString"
-  ByteStringBuilder -> "BB.Builder"
-  ShortByteString -> "SB.ShortByteString"
-  StrictText -> "T.Text"
-  LazyText -> "LT.Text"
-  TextBuilder -> "TB.Builder"
+cB :: B.ByteString
+cB = B.pack [0xec, 0x95, 0x88, 0xeb, 0x85, 0x95]
+{-# NOINLINE cB #-}
 
-data Strategy
-  = ConvFunc ByteString
-  | Via StringType
+cLB :: LB.ByteString
+cLB = LB.pack [0xec, 0x95, 0x88, 0xeb, 0x85, 0x95]
+{-# NOINLINE cLB #-}
 
-type Row = (StringType, StringType, Strategy)
+cBB :: BB.Builder
+cBB = BB.byteString cB
+{-# NOINLINE cBB #-}
 
-mappings :: [Row]
-mappings =
-  [ (String, StrictByteString, Via StrictText)
-  , (String, LazyByteString, Via LazyText)
-  , (String, ByteStringBuilder, ConvFunc "BB.stringUtf8")
-  , (String, ShortByteString, Via StrictByteString)
-  , (String, StrictText, ConvFunc "T.pack")
-  , (String, LazyText, ConvFunc "LT.pack")
-  , (String, TextBuilder, ConvFunc "TB.fromString")
-  , (StrictByteString, String, Via StrictText)
-  , (StrictByteString, LazyByteString, ConvFunc "LB.fromStrict")
-  , (StrictByteString, ByteStringBuilder, ConvFunc "BB.byteString")
-  , (StrictByteString, ShortByteString, ConvFunc "SB.toShort")
-  , (StrictByteString, StrictText, ConvFunc "TE.decodeUtf8Lenient")
-  , (StrictByteString, LazyText, Via LazyByteString)
-  , (StrictByteString, TextBuilder, Via StrictText)
-  , (LazyByteString, String, Via LazyText)
-  , (LazyByteString, StrictByteString, ConvFunc "LB.toStrict")
-  , (LazyByteString, ByteStringBuilder, ConvFunc "BB.lazyByteString")
-  , (LazyByteString, ShortByteString, Via StrictByteString)
-  , (LazyByteString, StrictText, Via StrictByteString)
-  , (LazyByteString, LazyText, ConvFunc "LTE.decodeUtf8With TEE.lenientDecode")
-  , (LazyByteString, TextBuilder, Via LazyText)
-  , (ByteStringBuilder, String, Via LazyText)
-  , (ByteStringBuilder, StrictByteString, Via LazyByteString)
-  , (ByteStringBuilder, LazyByteString, ConvFunc "BB.toLazyByteString")
-  , (ByteStringBuilder, ShortByteString, Via StrictByteString)
-  , (ByteStringBuilder, StrictText, Via StrictByteString)
-  , (ByteStringBuilder, LazyText, Via LazyByteString)
-  , (ByteStringBuilder, TextBuilder, Via LazyByteString)
-  , (ShortByteString, String, Via StrictByteString)
-  , (ShortByteString, StrictByteString, ConvFunc "SB.fromShort")
-  , (ShortByteString, LazyByteString, Via StrictByteString)
-  , (ShortByteString, ByteStringBuilder, ConvFunc "BB.shortByteString")
-  , (ShortByteString, StrictText, Via StrictByteString)
-  , (ShortByteString, LazyText, Via StrictByteString)
-  , (ShortByteString, TextBuilder, Via StrictByteString)
-  , (StrictText, String, ConvFunc "T.unpack")
-  , (StrictText, StrictByteString, ConvFunc "TE.encodeUtf8")
-  , (StrictText, LazyByteString, Via LazyText)
-  , (StrictText, ByteStringBuilder, ConvFunc "TE.encodeUtf8Builder")
-  , (StrictText, ShortByteString, Via StrictByteString)
-  , (StrictText, LazyText, ConvFunc "LT.fromStrict")
-  , (StrictText, TextBuilder, ConvFunc "TB.fromText")
-  , (LazyText, String, ConvFunc "LT.unpack")
-  , (LazyText, StrictByteString, Via LazyByteString)
-  , (LazyText, LazyByteString, ConvFunc "LTE.encodeUtf8")
-  , (LazyText, ByteStringBuilder, ConvFunc "LTE.encodeUtf8Builder")
-  , (LazyText, ShortByteString, Via StrictByteString)
-  , (LazyText, StrictText, ConvFunc "LT.toStrict")
-  , (LazyText, TextBuilder, ConvFunc "TB.fromLazyText")
-  , (TextBuilder, String, Via LazyText)
-  , (TextBuilder, StrictByteString, Via LazyText)
-  , (TextBuilder, LazyByteString, Via LazyText)
-  , (TextBuilder, ByteStringBuilder, Via LazyText)
-  , (TextBuilder, ShortByteString, Via LazyText)
-  , (TextBuilder, StrictText, Via LazyText)
-  , (TextBuilder, LazyText, ConvFunc "TB.toLazyText")
-  ]
+cSB :: SB.ShortByteString
+cSB = SB.pack [0xec, 0x95, 0x88, 0xeb, 0x85, 0x95]
+{-# NOINLINE cSB #-}
 
-fullyQualifiedModule :: ByteString -> ByteString
-fullyQualifiedModule = \case
-  "B" -> "Data.ByteString"
-  "BB" -> "Data.ByteString.Builder"
-  "LB" -> "Data.ByteString.Lazy"
-  "SB" -> "Data.ByteString.Short"
-  "T" -> "Data.Text"
-  "TE" -> "Data.Text.Encoding"
-  "TEE" -> "Data.Text.Encoding.Error"
-  "LT" -> "Data.Text.Lazy"
-  "TB" -> "Data.Text.Lazy.Builder"
-  "LTE" -> "Data.Text.Lazy.Encoding"
-  unknown -> error $ show unknown <> " is not a correct module name"
+cT :: T.Text
+cT = T.pack "\50504\45397"
+{-# NOINLINE cT #-}
 
-fullyQualifiedExpr :: ByteString -> ByteString
-fullyQualifiedExpr expr = fullyQualifiedModule moduleName <> rest
- where
-  (moduleName, rest) = B.break (0x2e ==) expr
+cLT :: LT.Text
+cLT = LT.pack "\50504\45397"
+{-# NOINLINE cLT #-}
 
-forceLookup :: (Show k, Eq k) => k -> [(k, v)] -> v
-forceLookup key table = fromMaybe (error $ "key " <> show key <> " not found") $ lookup key table
+cTB :: TB.Builder
+cTB = TB.fromString "\50504\45397"
+{-# NOINLINE cTB #-}
 
-getStrategy
-  :: StringType -> StringType -> [Row] -> Strategy
-getStrategy fromType toType table = forceLookup (fromType, toType) kvTable
+assertEq :: (Eq term) => String -> term -> term -> IO ()
+assertEq comment leftTerm rightTerm
+  | leftTerm == rightTerm = report
+  | otherwise = report >> exitFailure
  where
-  kvTable = flip map table $ \(a, b, c) -> ((a, b), c)
-
-getMapping
-  :: Row -> [Row] -> [ByteString]
-getMapping (fromType, toType, strategy) table = case strategy of
-  ConvFunc expr -> [expr]
-  Via intermediate ->
-    let formerStrategy = getStrategy fromType intermediate table
-        formerPart = getMapping (fromType, intermediate, formerStrategy) table
-        latterStrategy = getStrategy intermediate toType table
-        latterPart = getMapping (intermediate, toType, latterStrategy) table
-     in latterPart ++ formerPart
+  report = putStrLn comment
 
+-- TODO: More test cases
+-- NOTE: Data.ByteString.Builder.Builder does not have Eq
 main :: IO ()
 main = do
-  args <- getArgs
-  let noDiff = "--no-diff" `elem` args
-      shouldKeepFile = noDiff || "--keep" `elem` args
-  bracket acquire (release shouldKeepFile) $ \(tmpPath, hdl) -> do
-    B.putStr $ tmpPath <> "\n"
-    B.hPutBuilder hdl $ header <> mconcat instancePart
-    hClose hdl
-
-    unless noDiff $ do
-      diffExitCode <- runDiff tmpPath
-      exitWith diffExitCode
- where
-  acquire = mkstemps "haskell-from-" ".hs"
-  release shouldKeepFile (path, hdl)
-    | shouldKeepFile = hClose hdl
-    | otherwise = hClose hdl >> removeFile path
-
-  runDiff path =
-    runProcess
-      "diff"
-      ["-u", "--color=always", path, "src/From/String/AutoGen.hs"]
-
-  instanceLine fromType toType =
-    mconcat
-      [ "instance From "
-      , stringTypeName fromType
-      , " "
-      , stringTypeName toType
-      , " where\n"
-      ]
-  instancePart =
-    [ let exprs = getMapping row mappings
-          quote b = "'" <> b <> "'"
-       in mconcat
-            [ "\n"
-            , "-- | "
-            , mconcat
-                $ intersperse " "
-                $ map
-                  (quote . B.byteString)
-                $ intercalate ["."]
-                -- Split by space, to link each part in the expression
-                $ map (map fullyQualifiedExpr . B.split 0x20) exprs
-            , "\n"
-            , instanceLine fromType toType
-            , "  from = "
-            , mconcat
-                $ intersperse
-                  " . "
-                $ map
-                  B.byteString
-                  exprs
-            , "\n"
-            ]
-    | row@(fromType, toType, _) <- mappings
-    ]
-
-runProcess :: RawFilePath -> [ByteString] -> IO ExitCode
-runProcess cmd args = startProcess (proc cmd args) >>= waitForProcess
+  assertEq " cB == from cLB" cB (from cLB)
+  assertEq " cB == from cBB" cB (from cBB)
+  assertEq " cB == from cSB" cB (from cSB)
+  assertEq " cB == from cT" cB (from cT)
+  assertEq " cB == from cLT" cB (from cLT)
+  assertEq " cB == from cTB" cB (from cTB)
+  assertEq "cLB == from cB" cLB (from cB)
+  assertEq "cLB == from cBB" cLB (from cBB)
+  assertEq "cLB == from cSB" cLB (from cSB)
+  assertEq "cLB == from cT" cLB (from cT)
+  assertEq "cLB == from cLT" cLB (from cLT)
+  assertEq "cLB == from cTB" cLB (from cTB)
+  assertEq "cSB == from cB" cSB (from cB)
+  assertEq "cSB == from cLB" cSB (from cLB)
+  assertEq "cSB == from cBB" cSB (from cBB)
+  assertEq "cSB == from cT" cSB (from cT)
+  assertEq "cSB == from cLT" cSB (from cLT)
+  assertEq "cSB == from cTB" cSB (from cTB)
+  assertEq " cT == from cB" cT (from cB)
+  assertEq " cT == from cLB" cT (from cLB)
+  assertEq " cT == from cBB" cT (from cBB)
+  assertEq " cT == from cSB" cT (from cSB)
+  assertEq " cT == from cLT" cT (from cLT)
+  assertEq " cT == from cTB" cT (from cTB)
+  assertEq "cLT == from cB" cLT (from cB)
+  assertEq "cLT == from cLB" cLT (from cLB)
+  assertEq "cLT == from cBB" cLT (from cBB)
+  assertEq "cLT == from cSB" cLT (from cSB)
+  assertEq "cLT == from cT" cLT (from cT)
+  assertEq "cLT == from cTB" cLT (from cTB)
+  assertEq "cTB == from cB" cTB (from cB)
+  assertEq "cTB == from cLB" cTB (from cLB)
+  assertEq "cTB == from cBB" cTB (from cBB)
+  assertEq "cTB == from cSB" cTB (from cSB)
+  assertEq "cTB == from cT" cTB (from cT)
+  assertEq "cTB == from cLT" cTB (from cLT)
 
-header :: Builder
-header =
-  "{- FOURMOLU_DISABLE -}\n\
-  \{- Make sure you edit test/Main.hs -}\n\
-  \{-# LANGUAGE FlexibleInstances #-}\n\
-  \{-# LANGUAGE MultiParamTypeClasses #-}\n\
-  \{-# OPTIONS_GHC -Wno-orphans #-}\n\
-  \\n\
-  \module From.String.AutoGen () where\n\
-  \\n\
-  \import qualified Data.ByteString as B\n\
-  \import qualified Data.ByteString.Builder as BB\n\
-  \import qualified Data.ByteString.Lazy as LB\n\
-  \import qualified Data.ByteString.Short as SB\n\
-  \import qualified Data.Text as T\n\
-  \import qualified Data.Text.Encoding as TE\n\
-  \import qualified Data.Text.Encoding.Error as TEE\n\
-  \import qualified Data.Text.Lazy as LT\n\
-  \import qualified Data.Text.Lazy.Builder as TB\n\
-  \import qualified Data.Text.Lazy.Encoding as LTE\n\
-  \import From (From (..))\n"
+  exitSuccess