fakedata-1.0: test/TextSpec.hs

{-# LANGUAGE ScopedTypeVariables #-}

module TextSpec where

import Data.Text (Text)
import qualified Data.Text as T
import Faker hiding (defaultFakerSettings)
import qualified Faker.Address as FA
import qualified Faker.Ancient as AN
import qualified Faker.App as AP
import qualified Faker.Appliance as AP
import qualified Faker.Artist as AR
import qualified Faker.Bank as BA
import qualified Faker.Barcode as BC
import qualified Faker.Beer as BE
import qualified Faker.Blood as BL
import qualified Faker.Book as BO
import qualified Faker.Book.CultureSeries as CE
import qualified Faker.Book.Dune as DU
import qualified Faker.Book.Lovecraft as LO
import qualified Faker.BossaNova as BO
import qualified Faker.Business as BU
import qualified Faker.Cannabis as CA
import qualified Faker.Chiquito as CI
import qualified Faker.ChuckNorris as CH
import qualified Faker.Code as CO
import qualified Faker.Coffee as CO
import qualified Faker.Coin as CO
import qualified Faker.Color as CO
import qualified Faker.Commerce as CO
import qualified Faker.Company as CM
import qualified Faker.Compass as CO
import qualified Faker.Computer as COM
import qualified Faker.Construction as CO
import qualified Faker.Cosmere as CO
import qualified Faker.Creature.Animal as AN
import qualified Faker.Creature.Cat as CA
import qualified Faker.Creature.Dog as DO
import qualified Faker.Creature.Horse as HO
import qualified Faker.CryptoCoin as CO
import qualified Faker.Currency as CU
import qualified Faker.DcComics as DC
import qualified Faker.Demographic as DE
import qualified Faker.Dessert as DE
import qualified Faker.Dnd as DN
import qualified Faker.DrivingLicense as DR
import qualified Faker.Drone as DX
import qualified Faker.Educator as ED
import qualified Faker.ElectricalComponents as EC
import qualified Faker.Esport as ES
import qualified Faker.File as FI
import qualified Faker.Finance as FI
import qualified Faker.Food as FO
import qualified Faker.FunnyName as FU
import qualified Faker.Game.Control as GC
import qualified Faker.Game.Dota as DO
import qualified Faker.Game.ElderScrolls as EL
import qualified Faker.Game.Fallout as FA
import qualified Faker.Game.HalfLife as HA
import qualified Faker.Game.Heroes as HE
import qualified Faker.Game.HeroesOfTheStorm as HS
import qualified Faker.Game.Minecraft as MC
import qualified Faker.Game.Myst as MY
import qualified Faker.Game.Overwatch as OV
import qualified Faker.Game.Pokemon as PO
import qualified Faker.Game.SonicTheHedgehog as SO
import qualified Faker.Game.StreetFighter as SF
import qualified Faker.Game.SuperSmashBros as SU
import qualified Faker.Game.WarhammerFantasy as WF
import qualified Faker.Game.Witcher as WI
import qualified Faker.Game.WorldOfWarcraft as WO
import qualified Faker.Game.Zelda as ZE
import qualified Faker.Gender as GE
import qualified Faker.GreekPhilosophers as GR
import qualified Faker.Hacker as HA
import qualified Faker.Hipster as HI
import qualified Faker.House as HO
import qualified Faker.IndustrySegments as IN
import qualified Faker.Internet as IN
import qualified Faker.JapaneseMedia.DragonBall as DR
import qualified Faker.JapaneseMedia.OnePiece as ON
import qualified Faker.JapaneseMedia.StudioGhibli as GI
import qualified Faker.JapaneseMedia.SwordArtOnline as SW
import qualified Faker.Job as JO
import qualified Faker.Kpop as KP
import qualified Faker.LeagueOfLegends as LE
import qualified Faker.Lorem as LM
import qualified Faker.Markdown as MA
import qualified Faker.Marketing as MA
import qualified Faker.Measurement as ME
import qualified Faker.Military as MI
import qualified Faker.Movie as MO
import qualified Faker.Movie.BackToTheFuture as BA
import qualified Faker.Movie.Departed as MD
import qualified Faker.Movie.Ghostbusters as GH
import qualified Faker.Movie.GratefulDead as GR
import qualified Faker.Movie.HarryPotter as HA
import qualified Faker.Movie.HitchhikersGuideToTheGalaxy as HI
import qualified Faker.Movie.Lebowski as LE
import qualified Faker.Movie.PrincessBride as PR
import qualified Faker.Movie.StarWars as ST
import qualified Faker.Movie.VForVendetta as VF
import qualified Faker.Music as MU
import qualified Faker.Music.Opera as OP
import qualified Faker.Music.PearlJam as PJ
import qualified Faker.Music.Phish as PH
import qualified Faker.Music.Prince as PC
import qualified Faker.Music.RockBand as RO
import qualified Faker.Music.Rush as RU
import qualified Faker.Music.UmphreysMcgee as UM
import qualified Faker.Name as NA
import qualified Faker.Nation as NA
import qualified Faker.NatoPhoneticAlphabet as NA
import qualified Faker.PhoneNumber as PH
import qualified Faker.ProgrammingLanguage as PR
import qualified Faker.Quote as QU
import qualified Faker.Quote.Shakespeare as SH
import qualified Faker.Rajnikanth as RK
import qualified Faker.Relationship as RE
import qualified Faker.Restaurant as RE
import qualified Faker.Science as SC
import qualified Faker.Show as WS
import qualified Faker.SlackEmoji as SL
import qualified Faker.Source as SO
import qualified Faker.Space as SP
import qualified Faker.Sport.Basketball as BA
import qualified Faker.Sport.Football as FO
import qualified Faker.Subscription as SU
import qualified Faker.Superhero as SU
import qualified Faker.Team as TE
import qualified Faker.TvShow.AquaTeenHungerForce as AQ
import qualified Faker.TvShow.BigBangTheory as BB
import qualified Faker.TvShow.BoJackHorseman as BO
import qualified Faker.TvShow.BreakingBad as BR
import qualified Faker.TvShow.Buffy as BU
import qualified Faker.TvShow.Community as CO
import qualified Faker.TvShow.DrWho as DR
import qualified Faker.TvShow.DumbAndDumber as DD
import qualified Faker.TvShow.FamilyGuy as FA
import qualified Faker.TvShow.FreshPrinceOfBelAir as FR
import qualified Faker.TvShow.Friends as FI
import qualified Faker.TvShow.Futurama as FT
import qualified Faker.TvShow.GameOfThrones as GA
import qualified Faker.TvShow.HeyArnold as HE
import qualified Faker.TvShow.HowIMetYourMother as HI
import qualified Faker.TvShow.MichaelScott as MI
import qualified Faker.TvShow.NewGirl as NE
import qualified Faker.TvShow.ParksAndRec as PA
import qualified Faker.TvShow.RickAndMorty as RI
import qualified Faker.TvShow.Rupaul as RU
import qualified Faker.TvShow.Seinfeld as SE
import qualified Faker.TvShow.SiliconValley as SI
import qualified Faker.TvShow.Simpsons as SS
import qualified Faker.TvShow.SouthPark as SO
import qualified Faker.TvShow.StarTrek as SR
import qualified Faker.TvShow.Stargate as SG
import qualified Faker.TvShow.StrangerThings as SH
import qualified Faker.TvShow.Suits as SU
import qualified Faker.TvShow.TheExpanse as TH
import qualified Faker.TvShow.TheItCrowd as TI
import qualified Faker.TvShow.TheThickOfIt as TO
import qualified Faker.TvShow.TwinPeaks as TW
import qualified Faker.TvShow.VentureBros as VE
import qualified Faker.University as UN
import qualified Faker.Vehicle as VE
import qualified Faker.Verbs as VE
import qualified Faker.WorldCup as WO
import qualified Faker.Yoda as YO
import           System.IO.Unsafe (unsafePerformIO)
import qualified Faker
import Faker (Fake)
import System.Random (mkStdGen)
import           Text.Regex.TDFA         hiding (empty)
import Test.Hspec.QuickCheck(prop)
import qualified Test.QuickCheck as Q
import Test.Hspec
import TestImport

isText :: Text -> Bool
isText x = T.length x >= 1

fakerSettings :: FakerSettings
fakerSettings = defaultFakerSettings

verifyFakes :: [Fake Text] -> IO [Bool]
verifyFakes funs = do
  let fs :: [IO Text] = map (generateWithSettings fakerSettings) funs
      gs :: [IO Bool] = map (\f -> isText <$> f) fs
  sequence gs

verifyFakeInt :: [Fake Int] -> IO [Bool]
verifyFakeInt funs = do
  let fs :: [IO Int] = map (generateWithSettings fakerSettings) funs
      gs :: [IO Bool] = map (\f -> (\x -> x >= 0) <$> f) fs
  sequence gs

-- copied from https://github.com/parsonsmatt/hedgehog-fakedata/blob/d342c6eb5aeb9990bb36ede1d1f08becc7d71e16/src/Hedgehog/Gen/Faker.hs
-- I need it for hedhog but it's a cyclic dependency
-- made it work for quickeck instead of hedgehog.
-- who needs side affects anyway?
--
--  Select a value 'Fake' program in 'Gen'.
fakeQuickcheck :: Fake a -> Q.Gen a
fakeQuickcheck f = do
    randomGen <- mkStdGen <$> Q.choose (minBound, maxBound)
    pure $!
        unsafePerformIO $
        Faker.generateWithSettings
            (Faker.setRandomGen
              randomGen
              fakerSettings
            )
            f

isDomain :: Text -> Bool
isDomain = (=~ "^[A-Za-z_]+\\.[a-z]{1,4}$") . T.unpack

isName :: Text -> Bool
isName = (=~ "^[A-Za-z_]+$") . T.unpack

isNum :: Text -> Bool
isNum = (=~ "^[0-9]+$") . T.unpack

isEmail :: Text -> Bool
isEmail input =
  if (length splitAt /= 2) || (length splitDash /= 2) then False
  else
      isDomain domain && isName name && isNum num
  where
    splitAt = T.splitOn at input
    [nameNum, domain] = splitAt

    splitDash = T.splitOn dash nameNum
    [name, num] = splitDash

    dash :: Text
    dash = T.pack "-"

    at :: Text
    at = T.pack "@"

spec :: Spec
spec = do
  describe "TextSpec" $ do
    it "Address" $ do
      let functions :: [Fake Text] =
            [ FA.country,
              FA.cityPrefix,
              FA.citySuffix,
              FA.countryCode,
              FA.countryCodeLong,
              FA.buildingNumber,
              FA.communityPrefix,
              FA.communitySuffix,
              FA.community,
              FA.streetSuffix,
              FA.secondaryAddress,
              FA.postcode,
              FA.state,
              FA.stateAbbr,
              FA.timeZone,
              FA.city,
              FA.streetName,
              FA.streetAddress,
              FA.fullAddress,
              FA.mailBox,
              FA.cityWithState
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Ancient" $ do
      let functions :: [Fake Text] = [AN.god, AN.primordial, AN.hero, AN.titan]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "App" $ do
      let functions :: [Fake Text] = [AP.name, AP.version]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Appliance" $ do
      let functions :: [Fake Text] = [AP.brand, AP.equipment]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Artist" $ do
      let functions :: [Fake Text] = [AR.names]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Bank" $ do
      let functions :: [Fake Text] = [BA.name, BA.swiftBic]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Barcode" $ do
      let functions :: [Fake Text] =
            [ BC.ean8,
              BC.ean13,
              BC.upcA,
              BC.upcE,
              BC.compositeSymbol,
              BC.isbn,
              BC.ismn,
              BC.issn
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Beer" $ do
      let functions :: [Fake Text] =
            [BE.name, BE.brand, BE.hop, BE.yeast, BE.malt, BE.style]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Blood" $ do
      let functions :: [Fake Text] = [BL.type', BL.rhFactor, BL.group]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Book.CultureSeries" $ do
      let functions :: [Fake Text] =
            [ CE.books,
              CE.cultureShips,
              CE.cultureShipClasses,
              CE.cultureShipClassAbvs,
              CE.civs,
              CE.planets
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Book.Dune" $ do
      let functions :: [Fake Text] =
            [ DU.characters,
              DU.titles,
              DU.planets,
              DU.quotesGuildNavigator,
              DU.quotesEmperor,
              DU.quotesPaul,
              DU.quotesThufir,
              DU.quotesJessica,
              DU.quotesIrulan,
              DU.quotesMohiam,
              DU.quotesGurney,
              DU.quotesLeto,
              DU.quotesStilgar,
              DU.quotesLietKynes,
              DU.quotesPardotKynes,
              DU.quotesBaronHarkonnen,
              DU.quotesPiter,
              DU.quotesAlia,
              DU.quotesMapes,
              DU.quotesDuncan,
              DU.quotesYueh,
              DU.sayingsBeneGesserit,
              DU.sayingsFremen,
              DU.sayingsMentat,
              DU.sayingsMuaddib,
              DU.sayingsOrangeCatholicBible,
              DU.cities
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Book.LoveCraft" $ do
      let functions :: [Fake Text] =
            [LO.fhtagn, LO.deity, LO.location, LO.tome, LO.words]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Book" $ do
      let functions :: [Fake Text] =
            [BO.author, BO.title, BO.publisher, BO.genre]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "BossaNova" $ do
      let functions :: [Fake Text] = [BO.artists, BO.songs]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Business" $ do
      let functions :: [Fake Text] = [BU.creditCardNumbers, BU.creditCardTypes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Cannabis" $ do
      let functions :: [Fake Text] =
            [ CA.strains,
              CA.cannabinoidAbbreviations,
              CA.cannabinoids,
              CA.terpenes,
              CA.medicalUses,
              CA.healthBenefits,
              CA.categories,
              CA.types,
              CA.buzzwords,
              CA.brands
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "ChuckNorris" $ do
      let functions :: [Fake Text] = [CH.fact]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "RajniKanth" $ do
      let functions :: [Fake Text] = [RK.joke]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Show" $ do
      let functions :: [Fake Text] = [WS.adultMusical]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Chiquito" $ do
      let functions :: [Fake Text] =
            [CI.expressions, CI.terms, CI.sentences, CI.jokes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Code" $ do
      let functions :: [Fake Text] = [CO.asin]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "DnD" $ do
      let functions :: [Fake Text] =
            [ DN.klasses,
              DN.alignments,
              DN.cities,
              DN.languages,
              DN.meleeWeapons,
              DN.monsters,
              DN.races,
              DN.rangedWeapons
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Coffee" $ do
      let functions :: [Fake Text] =
            [ CO.country,
              CO.variety,
              CO.intensifier,
              CO.body,
              CO.descriptor,
              CO.name1,
              CO.name2,
              CO.notes,
              CO.blendName,
              CO.regionsColombia,
              CO.regionsBrazil,
              CO.regionsSumatra,
              CO.regionsEthiopia,
              CO.regionsHonduras,
              CO.regionsKenya,
              CO.regionsUganda,
              CO.regionsMexico,
              CO.regionsGuatemala,
              CO.regionsNicaragua,
              CO.regionsCostaRica,
              CO.regionsTanzania,
              CO.regionsElSalvador,
              CO.regionsRwanda,
              CO.regionsBurundi,
              CO.regionsPanama,
              CO.regionsYemen,
              CO.regionsIndia
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Coin" $ do
      let functions :: [Fake Text] = [CO.flip]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Color" $ do
      let functions :: [Fake Text] = [CO.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Computer" $ do
      let functions :: [Fake Text] =
            [COM.type', COM.platform, COM.osLinux, COM.osMacos, COM.osWindows]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Commerce" $ do
      let functions :: [Fake Text] =
            [ CO.department,
              CO.productNameAdjective,
              CO.productNameMaterial,
              CO.productNameProduct,
              CO.promotionCodeAdjective,
              CO.promotionCodeNoun
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Company" $ do
      let functions :: [Fake Text] =
            [ CM.suffix,
              CM.buzzword,
              CM.bs,
              CM.name,
              CM.industry,
              CM.profession,
              CM.type',
              CM.sicCode,
              CM.buzzword,
              CM.bs
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    describe "Company" $
      it "generated verify fake functions" $ do
        let functions :: [Fake Text] =
              [ CO.direction
              , CO.abbreviation
              , CO.azimuth
              , CO.cardinalWord
              , CO.cardinalAbbreviation
              , CO.cardinalAzimuth
              , CO.ordinalWord
              , CO.ordinalAbbreviation
              , CO.ordinalAzimuth
              , CO.halfWindWord
              , CO.halfWindAbbreviation
              , CO.halfWindAzimuth
              , CO.quarterWindWord
              , CO.quarterWindAbbreviation
              , CO.quarterWindAzimuth
              ]
        bools <- verifyFakes functions
        (and bools) `shouldBe` True
    describe "Company domain" $
      it "forall domain fullfils is a domain name regex" $ Q.property $ Q.forAll (fakeQuickcheck CM.domain) isDomain
    describe "Company email" $
      it "forall email fullfils is an email regex" $ Q.property $ Q.forAll (fakeQuickcheck CM.email) isEmail
    it "Construction" $ do
      let functions :: [Fake Text] =
            [ CO.materials,
              CO.subcontractCategories,
              CO.heavyEquipment,
              CO.roles,
              CO.trades,
              CO.standardCostCodes
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Cosmere" $ do
      let functions :: [Fake Text] =
            [ CO.aons,
              CO.shardWorlds,
              CO.shards,
              CO.surges,
              CO.knightsRadiant,
              CO.metals,
              CO.allomancers,
              CO.feruchemists,
              CO.heralds,
              CO.sprens
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Creature.Animal" $ do
      let functions :: [Fake Text] = [AN.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Creature.Cat" $ do
      let functions :: [Fake Text] = [CA.name, CA.breed, CA.registry]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Control" $ do
      let functions :: [Fake Text] =
            [ GC.character,
              GC.location,
              GC.objectOfPower,
              GC.alteredItem,
              GC.alteredWorldEvent,
              GC.hiss,
              GC.theBoard,
              GC.quote
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Creature.Dog" $ do
      let functions :: [Fake Text] =
            [ DO.name,
              DO.breed,
              DO.sound,
              DO.memePhrase,
              DO.age,
              DO.coatLength,
              DO.size
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Creature.Horuse" $ do
      let functions :: [Fake Text] = [HO.name, HO.breed]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Cryptocoin" $ do
      let functions :: [Fake Text] = [CO.coin]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Currency" $ do
      let functions :: [Fake Text] = [CU.name, CU.code, CU.symbol]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "DcComics" $ do
      let functions :: [Fake Text] =
            [DC.hero, DC.heroine, DC.villain, DC.name, DC.title]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Drone" $ do
      let functions :: [Fake Text] =
            [ DX.name,
              DX.batteryType,
              DX.iso,
              DX.photoFormat,
              DX.videoFormat,
              DX.maxShutterSpeed,
              DX.minShutterSpeed,
              DX.shutterSpeedUnits,
              DX.weight,
              DX.maxAscentSpeed,
              DX.maxDescentSpeed,
              DX.flightTime,
              DX.maxAltitude,
              DX.maxFlightDistance,
              DX.maxSpeed,
              DX.maxWindResistance,
              DX.maxAngularVelocity,
              DX.maxTiltAngle,
              DX.operatingTemperature,
              DX.batteryCapacity,
              DX.batteryVoltage,
              DX.batteryWeight,
              DX.chargingTemperature,
              DX.maxChargingPower,
              DX.maxResolution
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "DrivingLicense" $ do
      let functions :: [Fake Text] =
            [ DR.usaAlabama,
              DR.usaAlaska,
              DR.usaArizona,
              DR.usaArkansas,
              DR.usaCalifornia,
              DR.usaColorado,
              DR.usaConnecticut,
              DR.usaDelaware,
              DR.usaDistrictOfColumbia,
              DR.usaFlorida,
              DR.usaGeorgia,
              DR.usaHawaii,
              DR.usaIdaho,
              DR.usaIllinois,
              DR.usaIndiana,
              DR.usaIowa,
              DR.usaKansas,
              DR.usaKentucky,
              DR.usaLouisiana,
              DR.usaMaine,
              DR.usaMaryland,
              DR.usaMassachusetts,
              DR.usaMichigan,
              DR.usaMinnesota,
              DR.usaMississippi,
              DR.usaMissouri,
              DR.usaMontana,
              DR.usaNebraska,
              DR.usaNevada,
              DR.usaNewHampshire,
              DR.usaNewJersey,
              DR.usaNewMexico,
              DR.usaNewYork,
              DR.usaNorthCarolina,
              DR.usaOhio,
              DR.usaOklahoma,
              DR.usaOregon,
              DR.usaPennsylvania,
              DR.usaRhodeIsland,
              DR.usaSouthCarolina,
              DR.usaSouthDakota,
              DR.usaTennessee,
              DR.usaTexas,
              DR.usaUtah,
              DR.usaVermont,
              DR.usaVirginia,
              DR.usaWashington,
              DR.usaWestVirginia,
              DR.usaWisconsin,
              DR.usaWyoming,
              DR.usaNorthDakota
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Demographic" $ do
      let functions :: [Fake Text] =
            [ DE.race,
              DE.sex,
              DE.demonym,
              DE.educationalAttainment,
              DE.maritalStatus
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Dessert" $ do
      let functions :: [Fake Text] = [DE.variety, DE.topping, DE.flavor]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Educator" $ do
      let functions :: [Fake Text] =
            [ ED.schoolName,
              ED.secondary,
              ED.university,
              ED.secondarySchool,
              ED.campus,
              ED.subject,
              ED.degree,
              ED.courseName,
              ED.tertiaryUniversityType,
              ED.tertiaryDegreeType,
              ED.tertiaryDegreeCourseNumber,
              ED.primary,
              ED.primarySchool
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "ElectricalComponents" $ do
      let functions :: [Fake Text] =
            [EC.active, EC.passive, EC.electromechanical]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Esport" $ do
      let functions :: [Fake Text] =
            [ES.players, ES.teams, ES.events, ES.leagues, ES.games]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "File" $ do
      let functions :: [Fake Text] = [FI.extension, FI.mimeType]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Finance" $ do
      let functions :: [Fake Text] =
            [ FI.visa,
              FI.mastercard,
              FI.discover,
              FI.dinersClub,
              FI.jcb,
              FI.switch,
              FI.solo,
              FI.dankort,
              FI.maestro,
              FI.forbrugsforeningen,
              FI.laser
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Food" $ do
      let functions :: [Fake Text] =
            [ FO.dish,
              FO.descriptions,
              FO.ingredients,
              FO.fruits,
              FO.vegetables,
              FO.spices,
              FO.measurements,
              FO.measurementSizes,
              FO.metricMeasurements,
              FO.sushi
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "FunnyName" $ do
      let functions :: [Fake Text] = [FU.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Futurama" $ do
      let functions :: [Fake Text] =
            [ FT.characters,
              FT.locations,
              FT.quotes,
              FT.hermesCatchphrases
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Dota" $ do
      let functions :: [Fake Text] =
            [ DO.hero,
              DO.item,
              DO.team,
              DO.player,
              DO.abaddonQuote,
              DO.alchemistQuote,
              DO.axeQuote,
              DO.beastmasterQuote,
              DO.brewmasterQuote,
              DO.bristlebackQuote,
              DO.centaurQuote,
              DO.chaosKnightQuote,
              DO.clockwerkQuote,
              DO.doomQuote,
              DO.dragonKnightQuote,
              DO.earthSpiritQuote,
              DO.earthshakerQuote,
              DO.elderTitanQuote,
              DO.huskarQuote,
              DO.ioQuote,
              DO.kunkkaQuote,
              DO.legionCommanderQuote,
              DO.lifestealerQuote,
              DO.lycanQuote,
              DO.magnusQuote,
              DO.nightStalkerQuote,
              DO.omniknightQuote,
              DO.phoenixQuote,
              DO.pudgeQuote,
              DO.sandKingQuote,
              DO.slardarQuote,
              DO.spiritBreakerQuote,
              DO.svenQuote,
              DO.tidehunterQuote,
              DO.timbersawQuote,
              DO.tinyQuote,
              DO.tuskQuote,
              DO.underlordQuote,
              DO.undyingQuote,
              DO.wraithKingQuote,
              DO.meepoQuote
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.ElderScrolls" $ do
      let functions :: [Fake Text] =
            [ EL.race,
              EL.creature,
              EL.region,
              EL.dragon,
              EL.city,
              EL.firstName,
              EL.lastName
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Fallout" $ do
      let functions :: [Fake Text] =
            [FA.characters, FA.factions, FA.locations, FA.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.HalfLife" $ do
      let functions :: [Fake Text] = [HA.character, HA.enemy, HA.location]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Heroes" $ do
      let functions :: [Fake Text] = [HE.names, HE.specialties, HE.klasses]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.HeroesOfTheStorm" $ do
      let functions :: [Fake Text] =
            [ HS.battlegrounds,
              HS.classNames,
              HS.heroes,
              HS.quotes
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Myst" $ do
      let functions :: [Fake Text] =
            [MY.games, MY.creatures, MY.characters, MY.ages, MY.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Overwatch" $ do
      let functions :: [Fake Text] = [OV.heroes, OV.locations, OV.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.WarhammerFantasy" $ do
      let functions :: [Fake Text] =
            [ WF.creatures,
              WF.factions,
              WF.factions,
              WF.locations,
              WF.quotes,
              WF.heros
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Pokemon" $ do
      let functions :: [Fake Text] = [PO.names, PO.locations, PO.moves]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.SonicTheHedgehog" $ do
      let functions :: [Fake Text] = [SO.zone, SO.character, SO.game]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.SonicTheHedgehog" $ do
      let functions :: [Fake Text] = [SO.zone, SO.character, SO.game]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.SuperSmashBros" $ do
      let functions :: [Fake Text] = [SU.fighter, SU.stage]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Witcher" $ do
      let functions :: [Fake Text] =
            [ WI.characters,
              WI.witchers,
              WI.schools,
              WI.locations,
              WI.quotes,
              WI.monsters,
              WI.signs,
              WI.potions,
              WI.books
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.WorldOfwarcraft" $ do
      let functions :: [Fake Text] = [
                                 WO.heros
                                , WO.quotes
                                , WO.classNames
                                , WO.races
                                ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Zelda" $ do
      let functions :: [Fake Text] =
            [ZE.games, ZE.characters, ZE.locations, ZE.items]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.Minecraft" $ do
      let functions :: [Fake Text] =
            [ MC.blocks,
              MC.items,
              MC.mobs
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Game.StreetFighter" $ do
      let functions :: [Fake Text] =
            [ SF.characters,
              SF.stages,
              SF.quotes,
              SF.moves
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Gender" $ do
      let functions :: [Fake Text] =
            [GE.types, GE.binaryTypes, GE.shortBinaryTypes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "GreekPhilosophers" $ do
      let functions :: [Fake Text] = [GR.names, GR.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Hacker" $ do
      let functions :: [Fake Text] =
            [HA.abbreviation, HA.adjective, HA.noun, HA.verb, HA.ingverb]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Hipster" $ do
      let functions :: [Fake Text] = [HI.words]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "House" $ do
      let functions :: [Fake Text] = [HO.furniture, HO.rooms]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Industry" $ do
      let functions :: [Fake Text] =
            [IN.industry, IN.superSector, IN.sector, IN.subSector]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Internet" $ do
      let functions :: [Fake Text] =
            [ IN.freeEmail,
              IN.domainSuffix,
              IN.userAgentAol,
              IN.userAgentChrome,
              IN.userAgentFirefox,
              IN.userAgentInternetExplorer,
              IN.userAgentNetscape,
              IN.userAgentOpera,
              IN.userAgentSafari
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "JapaneseMedia.DragonBall" $ do
      let functions :: [Fake Text] = [DR.characters, DR.races, DR.planets]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "JapaneseMedia.OnePiece" $ do
      let functions :: [Fake Text] =
            [ ON.characters,
              ON.seas,
              ON.islands,
              ON.locations,
              ON.quotes,
              ON.akumasNoMi
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "JapaneseMedia.SwordArtOnline" $ do
      let functions :: [Fake Text] =
            [SW.realName, SW.gameName, SW.location, SW.item]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "JapaneseMedia.StudioGhibli" $ do
      let functions :: [Fake Text] =
            [ GI.characters,
              GI.quotes,
              GI.movies
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Job" $ do
      let functions :: [Fake Text] =
            [ JO.field,
              JO.seniority,
              JO.position,
              JO.keySkills,
              JO.employmentType,
              JO.educationLevel,
              JO.title
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Kpop" $ do
      let functions :: [Fake Text] =
            [ KP.iGroups,
              KP.iiGroups,
              KP.iiiGroups,
              KP.girlGroups,
              KP.boyBands,
              KP.solo
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "LeagueOfLegends" $ do
      let functions :: [Fake Text] =
            [ LE.champion,
              LE.location,
              LE.quote,
              LE.summonerSpell,
              LE.masteries,
              LE.rank
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Lorem" $ do
      let functions :: [Fake Text] = [LM.words, LM.supplemental]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Markdown" $ do
      let functions :: [Fake Text] = [MA.headers, MA.emphasis]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Marketing" $ do
      let functions :: [Fake Text] = [MA.buzzwords]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Measurement" $ do
      let functions :: [Fake Text] =
            [ ME.height,
              ME.length,
              ME.volume,
              ME.weight,
              ME.metricHeight,
              ME.metricLength,
              ME.metricVolume,
              ME.metricWeight
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Military" $ do
      let functions :: [Fake Text] =
            [ MI.armyRank,
              MI.marinesRank,
              MI.navyRank,
              MI.airForceRank,
              MI.dodPaygrade,
              MI.coastGuardRank,
              MI.spaceForceRank
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.Departed" $ do
      let functions :: [Fake Text] = [MD.actors, MD.characters, MD.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.BackToTheFuture" $ do
      let functions :: [Fake Text] = [BA.dates, BA.characters, BA.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.Ghostbusters" $ do
      let functions :: [Fake Text] = [GH.actors, GH.characters, GH.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.GratefulDead" $ do
      let functions :: [Fake Text] = [GR.players, GR.songs]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.HarryPotter" $ do
      let functions :: [Fake Text] =
            [ HA.characters,
              HA.locations,
              HA.quotes,
              HA.books,
              HA.houses,
              HA.spells
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.HitchhikersGuideToTheGalaxy" $ do
      let functions :: [Fake Text] =
            [ HI.characters,
              HI.locations,
              HI.marvinQuote,
              HI.planets,
              HI.quotes,
              HI.species,
              HI.starships
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.Lebowski" $ do
      let functions :: [Fake Text] = [LE.actors, LE.characters, LE.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.PrincessBride" $ do
      let functions :: [Fake Text] = [PR.characters, PR.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.StarWars" $ do
      let functions :: [Fake Text] =
            [ ST.characters,
              ST.callSquadrons,
              ST.droids,
              ST.planets,
              ST.species,
              ST.vehicles,
              ST.wookieeWords,
              ST.callNumbers,
              ST.callSign,
              ST.quotesAdmiralAckbar,
              ST.quotesAhsokaTano,
              ST.quotesAsajjVentress,
              ST.quotesBendu,
              ST.quotesBobaFett,
              ST.quotesC3po,
              ST.quotesCountDooku,
              ST.quotesDarthCaedus,
              ST.quotesDarthVader,
              ST.quotesEmperorPalpatine,
              ST.quotesFinn,
              ST.quotesGrandAdmiralThrawn,
              ST.quotesGrandMoffTarkin,
              ST.quotesGreedo,
              ST.quotesHanSolo,
              ST.quotesJabbaTheHutt,
              ST.quotesJarJarBinks,
              ST.quotesK2so,
              ST.quotesKyloRen,
              ST.quotesLandoCalrissian,
              ST.quotesLeiaOrgana,
              ST.quotesLukeSkywalker,
              ST.quotesMaceWindu,
              ST.quotesMazKanata,
              ST.quotesObiWanKenobi,
              ST.quotesPadmeAmidala,
              ST.quotesQuiGonJinn,
              ST.quotesRey,
              ST.quotesShmiSkywalker,
              ST.quotesYoda,
              ST.alternateCharacterSpellingsAdmiralAckbar,
              ST.alternateCharacterSpellingsAhsokaTano,
              ST.alternateCharacterSpellingsAnakinSkywalker,
              ST.alternateCharacterSpellingsAsajjVentress,
              ST.alternateCharacterSpellingsBendu,
              ST.alternateCharacterSpellingsBobaFett,
              ST.alternateCharacterSpellingsC3po,
              ST.alternateCharacterSpellingsCountDooku,
              ST.alternateCharacterSpellingsDarthCaedus,
              ST.alternateCharacterSpellingsDarthVader,
              ST.alternateCharacterSpellingsEmperorPalpatine,
              ST.alternateCharacterSpellingsFinn,
              ST.alternateCharacterSpellingsGeneralHux,
              ST.alternateCharacterSpellingsGrandAdmiralThrawn,
              ST.alternateCharacterSpellingsGrandMoffTarkin,
              ST.alternateCharacterSpellingsGreedo,
              ST.alternateCharacterSpellingsHanSolo,
              ST.alternateCharacterSpellingsJabbaTheHutt,
              ST.alternateCharacterSpellingsJarJarBinks,
              ST.alternateCharacterSpellingsK2so,
              ST.alternateCharacterSpellingsKyloRen,
              ST.alternateCharacterSpellingsLandoCalrissian,
              ST.alternateCharacterSpellingsLeiaOrgana,
              ST.alternateCharacterSpellingsLukeSkywalker,
              ST.alternateCharacterSpellingsMaceWindu,
              ST.alternateCharacterSpellingsMazKanata,
              ST.alternateCharacterSpellingsObiWanKenobi,
              ST.alternateCharacterSpellingsPadmeAmidala,
              ST.alternateCharacterSpellingsQuiGonJinn,
              ST.alternateCharacterSpellingsRey,
              ST.alternateCharacterSpellingsShmiSkywalker,
              ST.alternateCharacterSpellingsYoda
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie.VForVendetta" $ do
      let functions :: [Fake Text] = [VF.characters, VF.speeches, VF.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Movie" $ do
      let functions :: [Fake Text] = [MO.quote, MO.title]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.Opera" $ do
      let functions :: [Fake Text] =
            [ OP.italianByGiuseppeVerdi,
              OP.italianByGioacchinoRossini,
              OP.italianByGaetanoDonizetti,
              OP.italianByVincenzoBellini,
              OP.italianByChristophWillibaldGluck,
              OP.italianByWolfgangAmadeusMozart,
              OP.germanByWolfgangAmadeusMozart,
              OP.germanByLudwigVanBeethoven,
              OP.germanByCarlMariaVonWeber,
              OP.germanByRichardStrauss,
              OP.germanByRichardWagner,
              OP.germanByRobertSchumann,
              OP.germanByFranzSchubert,
              OP.germanByAlbanBerg,
              OP.frenchByChristophWillibaldGluck,
              OP.frenchByMauriceRavel,
              OP.frenchByHectorBerlioz,
              OP.frenchByGeorgesBizet,
              OP.frenchByCharlesGounod,
              OP.frenchByCamilleSaintSaëns
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.PearlJam" $ do
      let functions :: [Fake Text] =
            [ OP.italianByGiuseppeVerdi,
              OP.italianByGioacchinoRossini,
              OP.italianByGaetanoDonizetti,
              OP.italianByVincenzoBellini
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.Phish" $ do
      let functions :: [Fake Text] = [PH.songs, PH.musicians, PH.albums]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.RockBand" $ do
      let functions :: [Fake Text] = [RO.name, RO.song]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.UmphreysMcgee" $ do
      let functions :: [Fake Text] = [UM.song]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.Prince" $ do
      let functions :: [Fake Text] =
            [ PC.lyric,
              PC.song,
              PC.album,
              PC.band
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music.Rush" $ do
      let functions :: [Fake Text] =
            [ RU.players,
              RU.albums
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Music" $ do
      let functions :: [Fake Text] =
            [MU.instruments, MU.bands, MU.albums, MU.genres, MU.mamboNo5, MU.hiphopSubgenres
            , MU.hiphopGroups
            , MU.hiphopArtist]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Name" $ do
      let functions :: [Fake Text] =
            [ NA.maleFirstName,
              NA.femaleFirstName,
              NA.prefix,
              NA.suffix,
              NA.lastName,
              NA.name,
              NA.nameWithMiddle,
              NA.firstName
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Nation" $ do
      let functions :: [Fake Text] =
            [NA.nationality, NA.language, NA.capitalCity, NA.flagEmoji]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "NatoPhoneticAlphabet" $ do
      let functions :: [Fake Text] = [NA.codeWord]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "PhoneNumber" $ do
      let functions :: [Fake Text] =
            [PH.formats, PH.countryCode, PH.cellPhoneFormat]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "ProgrammingLanguage" $ do
      let functions :: [Fake Text] = [PR.name, PR.creator]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Quote.Shakespeare" $ do
      let functions :: [Fake Text] =
            [SH.hamlet, SH.asYouLikeIt, SH.kingRichardIii, SH.romeoAndJuliet]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Quote" $ do
      let functions :: [Fake Text] =
            [ QU.famousLastWords,
              QU.matz,
              QU.mostInterestingManInTheWorld,
              QU.robin,
              QU.singularSiegler,
              QU.yoda,
              QU.fortuneCookie
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Relationship" $ do
      let functions :: [Fake Text] =
            [ RE.inLaw,
              RE.spouse,
              RE.parent,
              RE.sibling,
              RE.familialDirect,
              RE.familialExtended
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Restaurant" $ do
      let functions :: [Fake Text] =
            [ RE.nameSuffix,
              RE.type',
              RE.description,
              RE.review,
              RE.namePrefix,
              RE.name
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Science" $ do
      let functions :: [Fake Text] =
            [SC.element, SC.elementSymbol, SC.scientist
            , SC.elementState, SC.elementSubcategory]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "SlackEmoji" $ do
      let functions :: [Fake Text] =
            [ SL.people,
              SL.nature,
              SL.foodAndDrink,
              SL.celebration,
              SL.activity,
              SL.travelAndPlaces,
              SL.objectsAndSymbols,
              SL.custom,
              SL.emoji
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Source" $ do
      let functions :: [Fake Text] =
            [ SO.helloWorldRuby,
              SO.helloWorldJavascript,
              SO.printRuby,
              SO.printJavascript,
              SO.print1To10Ruby,
              SO.print1To10Javascript
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Space" $ do
      let functions :: [Fake Text] =
            [ SP.planet,
              SP.moon,
              SP.galaxy,
              SP.nebula,
              SP.starCluster,
              SP.constellation,
              SP.star,
              SP.agency,
              SP.agencyAbv,
              SP.nasaSpaceCraft,
              SP.company,
              SP.distanceMeasurement,
              SP.meteorite,
              SP.launchVehicle
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Sport.Basketball" $ do
      let functions :: [Fake Text] =
            [BA.teams, BA.players, BA.coaches, BA.positions]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Sport.Football" $ do
      let functions :: [Fake Text] =
            [FO.teams, FO.players, FO.coaches, FO.competitions, FO.positions]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Subscription" $ do
      let functions :: [Fake Text] =
            [ SU.plans,
              SU.statuses,
              SU.paymentMethods,
              SU.subscriptionTerms,
              SU.paymentTerms
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Superhero" $ do
      let functions :: [Fake Text] =
            [SU.power, SU.prefix, SU.suffix, SU.descriptor, SU.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Team" $ do
      let functions :: [Fake Text] = [TE.creature, TE.sport, TE.mascot, TE.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "University" $ do
      let functions :: [Fake Text] = [UN.prefix, UN.suffix, UN.name]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Vehicle" $ do
      let functions :: [Fake Text] =
            [ VE.manufacture,
              VE.makes,
              VE.colors,
              VE.transmissions,
              VE.driveTypes,
              VE.fuelTypes,
              VE.styles,
              VE.carTypes,
              VE.carOptions,
              VE.standardSpecs,
              VE.licensePlate,
              VE.modelsByMakeBMW,
              VE.modelsByMakeAudi,
              VE.modelsByMakeToyota,
              VE.modelsByMakeChevy,
              VE.modelsByMakeFord,
              VE.modelsByMakeDodge,
              VE.modelsByMakeLincoln,
              VE.modelsByMakeBuick,
              VE.modelsByMakeHonda,
              VE.modelsByMakeNissan
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
      let ifunctions :: [Fake Int] = [VE.doors, VE.engineSizes]
      bools <- verifyFakeInt ifunctions
      (and bools) `shouldBe` True
    it "Verbs" $ do
      let functions :: [Fake Text] =
            [VE.base, VE.past, VE.pastParticiple, VE.simplePresent, VE.ingForm]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "WorldCup" $ do
      let functions :: [Fake Text] =
            [ WO.teams,
              WO.stadiums,
              WO.cities,
              WO.groupsGroupA,
              WO.groupsGroupB,
              WO.groupsGroupC,
              WO.groupsGroupD,
              WO.groupsGroupE,
              WO.groupsGroupF,
              WO.groupsGroupG,
              WO.groupsGroupH,
              WO.rostersEgyptCoach,
              WO.rostersEgyptGoalkeepers,
              WO.rostersEgyptDefenders,
              WO.rostersEgyptMidfielders,
              WO.rostersEgyptForwards,
              WO.rostersRussiaCoach,
              WO.rostersRussiaGoalkeepers,
              WO.rostersRussiaDefenders,
              WO.rostersRussiaMidfielders,
              WO.rostersRussiaForwards,
              WO.rostersSaudiArabiaCoach,
              WO.rostersSaudiArabiaGoalkeepers,
              WO.rostersSaudiArabiaDefenders,
              WO.rostersSaudiArabiaMidfielders,
              WO.rostersSaudiArabiaForwards,
              WO.rostersUruguayCoach,
              WO.rostersUruguayGoalkeepers,
              WO.rostersUruguayDefenders,
              WO.rostersUruguayMidfielders,
              WO.rostersUruguayForwards,
              WO.rostersIranCoach,
              WO.rostersIranGoalkeepers,
              WO.rostersIranDefenders,
              WO.rostersIranMidfielders,
              WO.rostersIranForwards,
              WO.rostersMoroccoCoach,
              WO.rostersMoroccoGoalkeepers,
              WO.rostersMoroccoDefenders,
              WO.rostersMoroccoMidfielders,
              WO.rostersMoroccoForwards,
              WO.rostersPortugalCoach,
              WO.rostersPortugalGoalkeepers,
              WO.rostersPortugalDefenders,
              WO.rostersPortugalMidfielders,
              WO.rostersPortugalForwards,
              WO.rostersSpainCoach,
              WO.rostersSpainGoalkeepers,
              WO.rostersSpainDefenders,
              WO.rostersSpainMidfielders,
              WO.rostersSpainForwards,
              WO.rostersAustraliaCoach,
              WO.rostersAustraliaGoalkeepers,
              WO.rostersAustraliaDefenders,
              WO.rostersAustraliaMidfielders,
              WO.rostersAustraliaForwards,
              WO.rostersDenmarkCoach,
              WO.rostersDenmarkGoalkeepers,
              WO.rostersDenmarkDefenders,
              WO.rostersDenmarkMidfielders,
              WO.rostersDenmarkForwards,
              WO.rostersFranceCoach,
              WO.rostersFranceGoalkeepers,
              WO.rostersFranceDefenders,
              WO.rostersFranceMidfielders,
              WO.rostersFranceForwards,
              WO.rostersPeruCoach,
              WO.rostersPeruGoalkeepers,
              WO.rostersPeruDefenders,
              WO.rostersPeruMidfielders,
              WO.rostersPeruForwards,
              WO.rostersArgentinaCoach,
              WO.rostersArgentinaGoalkeepers,
              WO.rostersArgentinaDefenders,
              WO.rostersArgentinaMidfielders,
              WO.rostersArgentinaForwards,
              WO.rostersCroatiaCoach,
              WO.rostersCroatiaGoalkeepers,
              WO.rostersCroatiaDefenders,
              WO.rostersCroatiaMidfielders,
              WO.rostersCroatiaForwards,
              WO.rostersIcelandCoach,
              WO.rostersIcelandGoalkeepers,
              WO.rostersIcelandDefenders,
              WO.rostersIcelandMidfielders,
              WO.rostersIcelandForwards,
              WO.rostersNigeriaCoach,
              WO.rostersNigeriaGoalkeepers,
              WO.rostersNigeriaDefenders,
              WO.rostersNigeriaMidfielders,
              WO.rostersNigeriaForwards,
              WO.rostersBrazilCoach,
              WO.rostersBrazilGoalkeepers,
              WO.rostersBrazilDefenders,
              WO.rostersBrazilMidfielders,
              WO.rostersBrazilForwards,
              WO.rostersCostaRicaCoach,
              WO.rostersCostaRicaGoalkeepers,
              WO.rostersCostaRicaDefenders,
              WO.rostersCostaRicaMidfielders,
              WO.rostersCostaRicaForwards,
              WO.rostersSerbiaCoach,
              WO.rostersSerbiaGoalkeepers,
              WO.rostersSerbiaDefenders,
              WO.rostersSerbiaMidfielders,
              WO.rostersSerbiaForwards,
              WO.rostersSwitzerlandCoach,
              WO.rostersSwitzerlandGoalkeepers,
              WO.rostersSwitzerlandDefenders,
              WO.rostersSwitzerlandMidfielders,
              WO.rostersSwitzerlandForwards,
              WO.rostersGermanyCoach,
              WO.rostersGermanyGoalkeepers,
              WO.rostersGermanyDefenders,
              WO.rostersGermanyMidfielders,
              WO.rostersGermanyForwards,
              WO.rostersMexicoCoach,
              WO.rostersMexicoGoalkeepers,
              WO.rostersMexicoDefenders,
              WO.rostersMexicoMidfielders,
              WO.rostersMexicoForwards,
              WO.rostersSouthKoreaCoach,
              WO.rostersSouthKoreaGoalkeepers,
              WO.rostersSouthKoreaDefenders,
              WO.rostersSouthKoreaMidfielders,
              WO.rostersSouthKoreaForwards,
              WO.rostersSwedenCoach,
              WO.rostersSwedenGoalkeepers,
              WO.rostersSwedenDefenders,
              WO.rostersSwedenMidfielders,
              WO.rostersSwedenForwards,
              WO.rostersBelgiumCoach,
              WO.rostersBelgiumGoalkeepers,
              WO.rostersBelgiumDefenders,
              WO.rostersBelgiumMidfielders,
              WO.rostersBelgiumForwards,
              WO.rostersEnglandCoach,
              WO.rostersEnglandGoalkeepers,
              WO.rostersEnglandDefenders,
              WO.rostersEnglandMidfielders,
              WO.rostersEnglandForwards,
              WO.rostersPanamaCoach,
              WO.rostersPanamaGoalkeepers,
              WO.rostersPanamaDefenders,
              WO.rostersPanamaMidfielders,
              WO.rostersPanamaForwards,
              WO.rostersTunisiaCoach,
              WO.rostersTunisiaGoalkeepers,
              WO.rostersTunisiaDefenders,
              WO.rostersTunisiaMidfielders,
              WO.rostersTunisiaForwards,
              WO.rostersColumbiaCoach,
              WO.rostersColumbiaGoalkeepers,
              WO.rostersColumbiaDefenders,
              WO.rostersColumbiaMidfielders,
              WO.rostersColumbiaForwards,
              WO.rostersJapanCoach,
              WO.rostersJapanGoalkeepers,
              WO.rostersJapanDefenders,
              WO.rostersJapanMidfielders,
              WO.rostersJapanForwards,
              WO.rostersPolandCoach,
              WO.rostersPolandGoalkeepers,
              WO.rostersPolandDefenders,
              WO.rostersPolandMidfielders,
              WO.rostersPolandForwards,
              WO.rostersSenegalCoach,
              WO.rostersSenegalGoalkeepers,
              WO.rostersSenegalDefenders,
              WO.rostersSenegalMidfielders,
              WO.rostersSenegalForwards
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "Yoda" $ do
      let functions :: [Fake Text] = [YO.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.AquaTeenHungerForce" $ do
      let functions :: [Fake Text] = [AQ.character, AQ.quote]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.BigBangTheory" $ do
      let functions :: [Fake Text] = [BB.characters, BB.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Suits" $ do
      let functions :: [Fake Text] = [SU.characters, SU.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.BoJackHorseman" $ do
      let functions :: [Fake Text] = [BO.character, BO.quote, BO.tongueTwister]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.BreakingBad" $ do
      let functions :: [Fake Text] = [BR.character, BR.episode]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Buffy" $ do
      let functions :: [Fake Text] =
            [BU.characters, BU.quotes, BU.actors, BU.bigBads, BU.episodes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Community" $ do
      let functions :: [Fake Text] = [CO.characters, CO.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.DrWho" $ do
      let functions :: [Fake Text] =
            [ DR.character,
              DR.theDoctors,
              DR.actors,
              DR.catchPhrases,
              DR.quotes,
              DR.villains,
              DR.species
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.DumbAndDumber" $ do
      let functions :: [Fake Text] = [DD.actors, DD.characters, DD.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.FamilyGuy" $ do
      let functions :: [Fake Text] = [FA.character, FA.location, FA.quote]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.FreshPrinceOfBelAir" $ do
      let functions :: [Fake Text] = [FR.characters, FR.actors, FR.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Friends" $ do
      let functions :: [Fake Text] = [FI.characters, FI.locations, FI.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Friends" $ do
      let functions :: [Fake Text] = [FI.characters, FI.locations, FI.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.GameOfThrones" $ do
      let functions :: [Fake Text] =
            [GA.characters, GA.houses, GA.cities, GA.quotes, GA.dragons]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.HeyArnold" $ do
      let functions :: [Fake Text] = [HE.characters, HE.locations, HE.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.HowIMetYourMother" $ do
      let functions :: [Fake Text] =
            [HI.character, HI.catchPhrase, HI.highFive, HI.quote]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.MichaelScott" $ do
      let functions :: [Fake Text] = [MI.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.NewGirl" $ do
      let functions :: [Fake Text] = [NE.characters, NE.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.ParksAndRec" $ do
      let functions :: [Fake Text] = [PA.characters, PA.cities]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.RickAndMorty" $ do
      let functions :: [Fake Text] = [RI.characters, RI.locations, RI.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Rupaul" $ do
      let functions :: [Fake Text] = [RU.queens, RU.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Seinfeld" $ do
      let functions :: [Fake Text] = [SE.character, SE.quote, SE.business]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Seinfeld" $ do
      let functions :: [Fake Text] = [SE.character, SE.quote, SE.business]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.SiliconValley" $ do
      let functions :: [Fake Text] =
            [ SI.characters,
              SI.companies,
              SI.quotes,
              SI.apps,
              SI.inventions,
              SI.mottos,
              SI.urls,
              SI.email
            ]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.Simpsons" $ do
      let functions :: [Fake Text] = [SS.characters, SS.locations, SS.quotes, SS.episodeTitles]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.SouthPark" $ do
      let functions :: [Fake Text] = [SO.characters, SO.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.StarTrek" $ do
      let functions :: [Fake Text] =
            [SR.character, SR.location, SR.specie, SR.villain]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.StarGate" $ do
      let functions :: [Fake Text] = [SG.characters, SG.planets, SG.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.StrangerThings" $ do
      let functions :: [Fake Text] = [SH.character, SH.quote]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.TheExpanse" $ do
      let functions :: [Fake Text] =
            [TH.characters, TH.locations, TH.ships, TH.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.TheItCrowd" $ do
      let functions :: [Fake Text] =
            [TI.actors, TI.characters, TI.emails, TI.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.TheThickOfIt" $ do
      let functions :: [Fake Text] =
            [TO.characters, TO.positions, TO.departments]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.TwinPeaks" $ do
      let functions :: [Fake Text] = [TW.characters, TW.locations, TW.quotes]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True
    it "TvShow.VentureBros" $ do
      let functions :: [Fake Text] =
            [VE.character, VE.organization, VE.vehicle, VE.quote]
      bools <- verifyFakes functions
      (and bools) `shouldBe` True