Test.Tasty.Inspection

Create a tasty TestTree from an Obligation:

{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -O -dsuppress-all -dno-suppress-type-signatures -fplugin=Test.Tasty.Inspection.Plugin #-}

import Test.Tasty
import Test.Tasty.Inspection

lhs :: (a -> b) -> Maybe a -> Bool
lhs f x = case fmap f x of
  Nothing -> True
  Just{}  -> False

rhs :: (a -> b) -> Maybe a -> Bool
rhs _ Nothing = True
rhs _ Just{}  = False

main :: IO ()
main = defaultMain $(inspectTest $ 'lhs === 'rhs)

This is not the same function as Test.Inspection.inspectTest: both return Q Exp, but this one represents TestTree instead of Result.

If you are unhappy with an autogenerated test name, amend it using testName:

inspectTest (obl { testName = Just "foo" })

To invert an obligation apply Test.Tasty.ExpectedFailure.expectFail.

Create a tasty TestTree, which tests several Obligations for the same Name, generating a testGroup.

Create a tasty TestTree, which tests an Obligation for several Names, generating a testGroup.

This data type describes an inspection testing obligation.

It is recommended to build it using mkObligation, for backwards compatibility when new fields are added. You can also use the more mnemonic convenience functions like (===) or hasNoType.

The obligation needs to be passed to inspect or inspectTest.

An optional name for the test

Creates an inspection obligation for the given function name with default values for the optional fields.

Properties of the obligation target to be checked.

Declare two functions to be equal (see EqualTo)

Declare two functions to be equal, but ignoring type lambdas, type arguments, type casts and hpc ticks (see EqualTo). Note that -fhpc can prevent some optimizations; build without for more reliable analysis.

Declare two functions to be equal as (==-) but also ignoring let bindings ordering (see EqualTo).

Declare that in a function’s implementation, the given type does not occur.

More precisely: No locally bound variable (let-bound, lambda-bound or pattern-bound) has a type that contains the given type constructor.

inspect $ fusedFunction `hasNoType` ''[]

Declare that given types do not occur in a function’s implementation.

Declare that a function’s implementation does not contain any generic types. This is just hasNoType applied to the usual type constructors used in GHC.Generics.

inspect $ hasNoGenerics genericFunction

Declare that a function's implementation does not include dictionaries.

More precisely: No locally bound variable (let-bound, lambda-bound or pattern-bound) has a type that contains a type that mentions a type class.

inspect $ hasNoTypeClasses specializedFunction

A variant of hasNoTypeClasses, which white-lists some type-classes.

inspect $ fieldLens `hasNoTypeClassesExcept` [''Functor]

Declare that a function's implementation does not use the given variable (either in terms or -- if it is a constructor -- in patterns).

inspect $ foo `doesNotUse` 'error

Declare that given entities do not occur in a function’s implementation.

Dump the Core of the value.

inspect $ coreOf 'foo

This is useful when you need to inspect some values manually.