{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Hledger.Cli.Utils
(
unsupportedOutputFormatError,
withJournalDo,
writeOutput,
writeOutputLazyText,
journalTransform,
journalReload,
journalReloadIfChanged,
journalFileIsNewer,
openBrowserOn,
writeFileWithBackup,
writeFileWithBackupIfChanged,
readFileStrictly,
pivotByOpts,
anonymiseByOpts,
journalSimilarTransaction,
postingsOrTransactionsReportAsText,
tests_Cli_Utils,
)
where
import Control.Exception as C
import Control.Monad.Except (ExceptT, liftIO)
import Data.List
import Data.Maybe
import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Builder as TB
import qualified Data.Text.Lazy.IO as TL
import Data.Time (Day)
import Data.Time.Clock.POSIX (POSIXTime, utcTimeToPOSIXSeconds)
import Lens.Micro ((^.))
import Safe (readMay, headMay)
import System.Console.CmdArgs
import System.Directory (getModificationTime, getDirectoryContents, copyFile, doesFileExist)
import System.Exit
import System.FilePath ((</>), splitFileName, takeDirectory)
import System.Info (os)
import System.Process (readProcessWithExitCode)
import Text.Printf
import Text.Regex.TDFA ((=~))
import Hledger.Cli.CliOptions
import Hledger.Cli.Anon
import Hledger.Data
import Hledger.Read
import Hledger.Reports
import Hledger.Utils
import Control.Monad (when)
unsupportedOutputFormatError :: String -> String
unsupportedOutputFormatError :: [Char] -> [Char]
unsupportedOutputFormatError [Char]
fmt = [Char]
"Sorry, output format \""forall a. [a] -> [a] -> [a]
++[Char]
fmtforall a. [a] -> [a] -> [a]
++[Char]
"\" is unrecognised or not yet supported for this kind of report."
withJournalDo :: CliOpts -> (Journal -> IO a) -> IO a
withJournalDo :: forall a. CliOpts -> (Journal -> IO a) -> IO a
withJournalDo CliOpts
opts Journal -> IO a
cmd = do
[[Char]]
journalpaths <- CliOpts -> IO [[Char]]
journalFilePathFromOpts CliOpts
opts
Either [Char] Journal
j <- forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT forall a b. (a -> b) -> a -> b
$ CliOpts -> Journal -> Journal
journalTransform CliOpts
opts forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InputOpts -> [[Char]] -> ExceptT [Char] IO Journal
readJournalFiles (CliOpts -> InputOpts
inputopts_ CliOpts
opts) [[Char]]
journalpaths
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. [Char] -> a
error' Journal -> IO a
cmd Either [Char] Journal
j
journalTransform :: CliOpts -> Journal -> Journal
journalTransform :: CliOpts -> Journal -> Journal
journalTransform CliOpts
opts =
CliOpts -> Journal -> Journal
anonymiseByOpts CliOpts
opts
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CliOpts -> Journal -> Journal
pivotByOpts CliOpts
opts
pivotByOpts :: CliOpts -> Journal -> Journal
pivotByOpts :: CliOpts -> Journal -> Journal
pivotByOpts CliOpts
opts =
case [Char] -> RawOpts -> Maybe [Char]
maybestringopt [Char]
"pivot" forall b c a. (b -> c) -> (a -> b) -> a -> c
. CliOpts -> RawOpts
rawopts_ forall a b. (a -> b) -> a -> b
$ CliOpts
opts of
Just [Char]
tag -> Text -> Journal -> Journal
journalPivot forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack [Char]
tag
Maybe [Char]
Nothing -> forall a. a -> a
id
anonymiseByOpts :: CliOpts -> Journal -> Journal
anonymiseByOpts :: CliOpts -> Journal -> Journal
anonymiseByOpts CliOpts
opts =
if InputOpts -> Bool
anon_ forall b c a. (b -> c) -> (a -> b) -> a -> c
. CliOpts -> InputOpts
inputopts_ forall a b. (a -> b) -> a -> b
$ CliOpts
opts
then forall a. Anon a => a -> a
anon
else forall a. a -> a
id
writeOutput :: CliOpts -> String -> IO ()
writeOutput :: CliOpts -> [Char] -> IO ()
writeOutput CliOpts
opts [Char]
s = do
Maybe [Char]
f <- CliOpts -> IO (Maybe [Char])
outputFileFromOpts CliOpts
opts
(forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Char] -> IO ()
putStr [Char] -> [Char] -> IO ()
writeFile Maybe [Char]
f) [Char]
s
writeOutputLazyText :: CliOpts -> TL.Text -> IO ()
writeOutputLazyText :: CliOpts -> Text -> IO ()
writeOutputLazyText CliOpts
opts Text
s = do
Maybe [Char]
f <- CliOpts -> IO (Maybe [Char])
outputFileFromOpts CliOpts
opts
(forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text -> IO ()
TL.putStr [Char] -> Text -> IO ()
TL.writeFile Maybe [Char]
f) Text
s
journalReloadIfChanged :: CliOpts -> Day -> Journal -> ExceptT String IO (Journal, Bool)
journalReloadIfChanged :: CliOpts -> Day -> Journal -> ExceptT [Char] IO (Journal, Bool)
journalReloadIfChanged CliOpts
opts Day
_d Journal
j = do
let maybeChangedFilename :: [Char] -> IO (Maybe [Char])
maybeChangedFilename [Char]
f = do Bool
newer <- Journal -> [Char] -> IO Bool
journalFileIsNewer Journal
j [Char]
f
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if Bool
newer then forall a. a -> Maybe a
Just [Char]
f else forall a. Maybe a
Nothing
[[Char]]
changedfiles <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM [Char] -> IO (Maybe [Char])
maybeChangedFilename (Journal -> [[Char]]
journalFilePaths Journal
j)
if Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
changedfiles
then do
Bool
verbose <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Bool
isLoud
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
verbose Bool -> Bool -> Bool
|| Int
debugLevel forall a. Ord a => a -> a -> Bool
>= Int
6) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => [Char] -> r
printf [Char]
"%s has changed, reloading\n" (forall a. [a] -> a
head [[Char]]
changedfiles)
Journal
newj <- CliOpts -> ExceptT [Char] IO Journal
journalReload CliOpts
opts
forall (m :: * -> *) a. Monad m => a -> m a
return (Journal
newj, Bool
True)
else
forall (m :: * -> *) a. Monad m => a -> m a
return (Journal
j, Bool
False)
journalReload :: CliOpts -> ExceptT String IO Journal
journalReload :: CliOpts -> ExceptT [Char] IO Journal
journalReload CliOpts
opts = do
[[Char]]
journalpaths <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. Show a => [Char] -> a -> a
dbg6 [Char]
"reloading files" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CliOpts -> IO [[Char]]
journalFilePathFromOpts CliOpts
opts
CliOpts -> Journal -> Journal
journalTransform CliOpts
opts forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InputOpts -> [[Char]] -> ExceptT [Char] IO Journal
readJournalFiles (CliOpts -> InputOpts
inputopts_ CliOpts
opts) [[Char]]
journalpaths
journalFileIsNewer :: Journal -> FilePath -> IO Bool
journalFileIsNewer :: Journal -> [Char] -> IO Bool
journalFileIsNewer Journal{jlastreadtime :: Journal -> POSIXTime
jlastreadtime=POSIXTime
tread} [Char]
f = do
Maybe POSIXTime
mtmod <- [Char] -> IO (Maybe POSIXTime)
maybeFileModificationTime [Char]
f
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Maybe POSIXTime
mtmod of
Just POSIXTime
tmod -> POSIXTime
tmod forall a. Ord a => a -> a -> Bool
> POSIXTime
tread
Maybe POSIXTime
Nothing -> Bool
False
maybeFileModificationTime :: FilePath -> IO (Maybe POSIXTime)
maybeFileModificationTime :: [Char] -> IO (Maybe POSIXTime)
maybeFileModificationTime [Char]
f = do
Bool
exists <- [Char] -> IO Bool
doesFileExist [Char]
f
if Bool
exists
then do
UTCTime
utc <- [Char] -> IO UTCTime
getModificationTime [Char]
f
forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ UTCTime -> POSIXTime
utcTimeToPOSIXSeconds UTCTime
utc
else
forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
openBrowserOn :: String -> IO ExitCode
openBrowserOn :: [Char] -> IO ExitCode
openBrowserOn = [[Char]] -> [Char] -> IO ExitCode
trybrowsers [[Char]]
browsers
where
trybrowsers :: [[Char]] -> [Char] -> IO ExitCode
trybrowsers ([Char]
b:[[Char]]
bs) [Char]
u1 = do
(ExitCode
e,[Char]
_,[Char]
_) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode [Char]
b [[Char]
u1] [Char]
""
case ExitCode
e of
ExitCode
ExitSuccess -> forall (m :: * -> *) a. Monad m => a -> m a
return ExitCode
ExitSuccess
ExitFailure Int
_ -> [[Char]] -> [Char] -> IO ExitCode
trybrowsers [[Char]]
bs [Char]
u1
trybrowsers [] [Char]
u1 = do
[Char] -> IO ()
putStrLn forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => [Char] -> r
printf [Char]
"Could not start a web browser (tried: %s)" forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [[a]] -> [a]
intercalate [Char]
", " [[Char]]
browsers
[Char] -> IO ()
putStrLn forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => [Char] -> r
printf [Char]
"Please open your browser and visit %s" [Char]
u1
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> ExitCode
ExitFailure Int
127
browsers :: [[Char]]
browsers | [Char]
osforall a. Eq a => a -> a -> Bool
==[Char]
"darwin" = [[Char]
"open"]
| [Char]
osforall a. Eq a => a -> a -> Bool
==[Char]
"mingw32" = [[Char]
"c:/Program Files/Mozilla Firefox/firefox.exe"]
| Bool
otherwise = [[Char]
"sensible-browser",[Char]
"gnome-www-browser",[Char]
"firefox"]
writeFileWithBackupIfChanged :: FilePath -> T.Text -> IO Bool
writeFileWithBackupIfChanged :: [Char] -> Text -> IO Bool
writeFileWithBackupIfChanged [Char]
f Text
t = do
Text
s <- [Char] -> IO Text
readFilePortably [Char]
f
if Text
t forall a. Eq a => a -> a -> Bool
== Text
s then forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
else [Char] -> IO ()
backUpFile [Char]
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> Text -> IO ()
T.writeFile [Char]
f Text
t forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
writeFileWithBackup :: FilePath -> String -> IO ()
writeFileWithBackup :: [Char] -> [Char] -> IO ()
writeFileWithBackup [Char]
f [Char]
t = [Char] -> IO ()
backUpFile [Char]
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> [Char] -> IO ()
writeFile [Char]
f [Char]
t
readFileStrictly :: FilePath -> IO T.Text
readFileStrictly :: [Char] -> IO Text
readFileStrictly [Char]
f = [Char] -> IO Text
readFilePortably [Char]
f forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
s -> forall a. a -> IO a
C.evaluate (Text -> Int
T.length Text
s) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Text
s
backUpFile :: FilePath -> IO ()
backUpFile :: [Char] -> IO ()
backUpFile [Char]
fp = do
[[Char]]
fs <- [Char] -> IO [[Char]]
safeGetDirectoryContents forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
takeDirectory forall a b. (a -> b) -> a -> b
$ [Char]
fp
let ([Char]
d,[Char]
f) = [Char] -> ([Char], [Char])
splitFileName [Char]
fp
versions :: [Int]
versions = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ([Char]
f [Char] -> [Char] -> Maybe Int
`backupNumber`) [[Char]]
fs
next :: Int
next = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum (Int
0forall a. a -> [a] -> [a]
:[Int]
versions) forall a. Num a => a -> a -> a
+ Int
1
f' :: [Char]
f' = forall r. PrintfType r => [Char] -> r
printf [Char]
"%s.%d" [Char]
f Int
next
[Char] -> [Char] -> IO ()
copyFile [Char]
fp ([Char]
d [Char] -> [Char] -> [Char]
</> [Char]
f')
safeGetDirectoryContents :: FilePath -> IO [FilePath]
safeGetDirectoryContents :: [Char] -> IO [[Char]]
safeGetDirectoryContents [Char]
"" = [Char] -> IO [[Char]]
getDirectoryContents [Char]
"."
safeGetDirectoryContents [Char]
fp = [Char] -> IO [[Char]]
getDirectoryContents [Char]
fp
backupNumber :: FilePath -> FilePath -> Maybe Int
backupNumber :: [Char] -> [Char] -> Maybe Int
backupNumber [Char]
f [Char]
g = case [Char]
g forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
RegexContext Regex source1 target) =>
source1 -> source -> target
=~ ([Char]
"^" forall a. [a] -> [a] -> [a]
++ [Char]
f forall a. [a] -> [a] -> [a]
++ [Char]
"\\.([0-9]+)$") of
([Char]
_::FilePath, [Char]
_::FilePath, [Char]
_::FilePath, [[Char]
ext::FilePath]) -> forall a. Read a => [Char] -> Maybe a
readMay [Char]
ext
([Char], [Char], [Char], [[Char]])
_ -> forall a. Maybe a
Nothing
journalSimilarTransaction :: CliOpts -> Journal -> T.Text -> Maybe Transaction
journalSimilarTransaction :: CliOpts -> Journal -> Text -> Maybe Transaction
journalSimilarTransaction CliOpts
cliopts Journal
j Text
desc = Maybe Transaction
mbestmatch
where
mbestmatch :: Maybe Transaction
mbestmatch = forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. [a] -> Maybe a
headMay [(Double, Transaction)]
bestmatches
bestmatches :: [(Double, Transaction)]
bestmatches =
forall a. Show a => (a -> [Char]) -> a -> a
dbg1With ([[Char]] -> [Char]
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"similar transactions:"forall a. a -> [a] -> [a]
:) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\(Double
score,Transaction{Integer
[Tag]
[Posting]
Maybe Day
(SourcePos, SourcePos)
Text
Status
Day
tindex :: Transaction -> Integer
tprecedingcomment :: Transaction -> Text
tsourcepos :: Transaction -> (SourcePos, SourcePos)
tdate :: Transaction -> Day
tdate2 :: Transaction -> Maybe Day
tstatus :: Transaction -> Status
tcode :: Transaction -> Text
tdescription :: Transaction -> Text
tcomment :: Transaction -> Text
ttags :: Transaction -> [Tag]
tpostings :: Transaction -> [Posting]
tpostings :: [Posting]
ttags :: [Tag]
tcomment :: Text
tdescription :: Text
tcode :: Text
tstatus :: Status
tdate2 :: Maybe Day
tdate :: Day
tsourcepos :: (SourcePos, SourcePos)
tprecedingcomment :: Text
tindex :: Integer
..}) -> forall r. PrintfType r => [Char] -> r
printf [Char]
"%0.3f %s %s" Double
score (forall a. Show a => a -> [Char]
show Day
tdate) Text
tdescription)) forall a b. (a -> b) -> a -> b
$
Journal -> Query -> Text -> Int -> [(Double, Transaction)]
journalTransactionsSimilarTo Journal
j Query
q Text
desc Int
10
q :: Query
q = ReportOpts -> Query
queryFromFlags forall a b. (a -> b) -> a -> b
$ ReportSpec -> ReportOpts
_rsReportOpts forall a b. (a -> b) -> a -> b
$ CliOpts -> ReportSpec
reportspec_ CliOpts
cliopts
postingsOrTransactionsReportAsText
:: Bool -> CliOpts -> (Int -> Int -> (a, [WideBuilder], [WideBuilder]) -> TB.Builder)
-> (a -> MixedAmount) -> (a -> MixedAmount) -> [a] -> TB.Builder
postingsOrTransactionsReportAsText :: forall a.
Bool
-> CliOpts
-> (Int -> Int -> (a, [WideBuilder], [WideBuilder]) -> Builder)
-> (a -> MixedAmount)
-> (a -> MixedAmount)
-> [a]
-> Builder
postingsOrTransactionsReportAsText Bool
alignAll CliOpts
opts Int -> Int -> (a, [WideBuilder], [WideBuilder]) -> Builder
itemAsText a -> MixedAmount
itemamt a -> MixedAmount
itembal [a]
report =
forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) s a b.
Traversable t =>
(s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL (Int, Int)
-> (a, [WideBuilder], [WideBuilder]) -> ((Int, Int), Builder)
renderItem (((a, [WideBuilder], [WideBuilder]) -> [WideBuilder]) -> Int
startWidth forall {a} {b} {c}. (a, b, c) -> b
amt, ((a, [WideBuilder], [WideBuilder]) -> [WideBuilder]) -> Int
startWidth forall {a} {b} {c}. (a, b, c) -> c
bal) [(a, [WideBuilder], [WideBuilder])]
itemsWithAmounts
where
minWidth :: Int
minWidth = Int
12
chunkSize :: Int
chunkSize = Int
1000
renderItem :: (Int, Int)
-> (a, [WideBuilder], [WideBuilder]) -> ((Int, Int), Builder)
renderItem (Int
amtWidth, Int
balWidth) item :: (a, [WideBuilder], [WideBuilder])
item@(a
_, [WideBuilder]
amt1, [WideBuilder]
bal1) = ((Int
amtWidth', Int
balWidth'), Builder
itemBuilder)
where
itemBuilder :: Builder
itemBuilder = Int -> Int -> (a, [WideBuilder], [WideBuilder]) -> Builder
itemAsText Int
amtWidth' Int
balWidth' (a, [WideBuilder], [WideBuilder])
item
amtWidth' :: Int
amtWidth' = if Bool
alignAll then Int
amtWidth else forall a. Ord a => [a] -> a
maximumStrict forall a b. (a -> b) -> a -> b
$ Int
amtWidth forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map WideBuilder -> Int
wbWidth [WideBuilder]
amt1
balWidth' :: Int
balWidth' = if Bool
alignAll then Int
balWidth else forall a. Ord a => [a] -> a
maximumStrict forall a b. (a -> b) -> a -> b
$ Int
balWidth forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map WideBuilder -> Int
wbWidth [WideBuilder]
bal1
startWidth :: ((a, [WideBuilder], [WideBuilder]) -> [WideBuilder]) -> Int
startWidth (a, [WideBuilder], [WideBuilder]) -> [WideBuilder]
f = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum forall a b. (a -> b) -> a -> b
$ Int
minWidth forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map WideBuilder -> Int
wbWidth (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (a, [WideBuilder], [WideBuilder]) -> [WideBuilder]
f [(a, [WideBuilder], [WideBuilder])]
startAlign)
where
startAlign :: [(a, [WideBuilder], [WideBuilder])]
startAlign = (if Bool
alignAll then forall a. a -> a
id else forall a. Int -> [a] -> [a]
take Int
chunkSize) [(a, [WideBuilder], [WideBuilder])]
itemsWithAmounts
itemsWithAmounts :: [(a, [WideBuilder], [WideBuilder])]
itemsWithAmounts = forall a b. (a -> b) -> [a] -> [b]
map (\a
x -> (a
x, MixedAmount -> [WideBuilder]
showAmt forall a b. (a -> b) -> a -> b
$ a -> MixedAmount
itemamt a
x, MixedAmount -> [WideBuilder]
showAmt forall a b. (a -> b) -> a -> b
$ a -> MixedAmount
itembal a
x)) [a]
report
showAmt :: MixedAmount -> [WideBuilder]
showAmt = AmountDisplayOpts -> MixedAmount -> [WideBuilder]
showMixedAmountLinesB AmountDisplayOpts
oneLine{displayColour :: Bool
displayColour=CliOpts
optsforall s a. s -> Getting a s a -> a
^.forall c. HasReportOptsNoUpdate c => Lens' c Bool
color__}
amt :: (a, b, c) -> b
amt = forall {a} {b} {c}. (a, b, c) -> b
second3
bal :: (a, b, c) -> c
bal = forall {a} {b} {c}. (a, b, c) -> c
third3
tests_Cli_Utils :: TestTree
tests_Cli_Utils = [Char] -> [TestTree] -> TestTree
testGroup [Char]
"Utils" [
]