tasty-th-0.1.3/0000755000000000000000000000000012421470120011447 5ustar0000000000000000tasty-th-0.1.3/tasty-th.cabal0000644000000000000000000000137112421470120014212 0ustar0000000000000000name: tasty-th version: 0.1.3 cabal-version: >= 1.6 build-type: Simple license: BSD3 license-file: BSD3.txt maintainer: Benno Fünfstück homepage: http://github.com/bennofs/tasty-th synopsis: Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell. description: A fork of of test-framework-th modified to use tasty instead of test-framework. category: Testing author: Oscar Finnsson & Emil Nordling & Benno Fünfstück library exposed-modules: Test.Tasty.TH build-depends: base >= 4 && < 5, tasty, language-haskell-extract >= 0.2, template-haskell hs-source-dirs: src other-extensions: TemplateHaskell source-repository head type: git location: https://github.com/bennofs/tasty-th.git tasty-th-0.1.3/Setup.lhs0000644000000000000000000000015612421470120013261 0ustar0000000000000000#!/usr/bin/runhaskell > module Main where > import Distribution.Simple > main :: IO () > main = defaultMain tasty-th-0.1.3/BSD3.txt0000644000000000000000000000300012421470120012674 0ustar0000000000000000Copyright (c) 2010, Oscar Finnsson Copyright (c) 2013-2014, Benno Fünfstück All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Oscar Finnsson nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Oscar Finnsson BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. tasty-th-0.1.3/src/0000755000000000000000000000000012421470120012236 5ustar0000000000000000tasty-th-0.1.3/src/Test/0000755000000000000000000000000012421470120013155 5ustar0000000000000000tasty-th-0.1.3/src/Test/Tasty/0000755000000000000000000000000012421470120014261 5ustar0000000000000000tasty-th-0.1.3/src/Test/Tasty/TH.hs0000644000000000000000000000664612421470120015144 0ustar0000000000000000----------------------------------------------------------------------------- -- -- Module : Test.Tasty.TH -- Copyright : Oscar Finnsson, Benno Fünfstück -- License : BSD3 -- -- Maintainer : Benno Fünfstück -- Stability : -- Portability : -- -- ----------------------------------------------------------------------------- {-# LANGUAGE TemplateHaskell #-} module Test.Tasty.TH ( testGroupGenerator , defaultMainGenerator ) where import Language.Haskell.TH import Language.Haskell.Extract import Test.Tasty -- | Generate the usual code and extract the usual functions needed in order to run HUnit/Quickcheck/Quickcheck2. -- All functions beginning with case_, prop_ or test_ will be extracted. -- -- > {-# OPTIONS_GHC -fglasgow-exts -XTemplateHaskell #-} -- > module MyModuleTest where -- > import Test.HUnit -- > import MainTestGenerator -- > -- > main = $(defaultMainGenerator) -- > -- > case_Foo = do 4 @=? 4 -- > -- > case_Bar = do "hej" @=? "hej" -- > -- > prop_Reverse xs = reverse (reverse xs) == xs -- > where types = xs :: [Int] -- > -- > test_Group = -- > [ testCase "1" case_Foo -- > , testProperty "2" prop_Reverse -- > ] -- -- will automagically extract prop_Reverse, case_Foo, case_Bar and test_Group and run them as well as present them as belonging to the testGroup 'MyModuleTest' such as -- -- > me: runghc MyModuleTest.hs -- > MyModuleTest: -- > Reverse: [OK, passed 100 tests] -- > Foo: [OK] -- > Bar: [OK] -- > Group: -- > 1: [OK] -- > 2: [OK, passed 100 tests] -- > -- > Properties Test Cases Total -- > Passed 2 3 5 -- > Failed 0 0 0 -- > Total 2 3 5 defaultMainGenerator :: ExpQ defaultMainGenerator = [| defaultMain $ testGroup $(locationModule) $ $(propListGenerator) ++ $(caseListGenerator) ++ $(testListGenerator)|] -- | Generate the usual code and extract the usual functions needed for a testGroup in HUnit/Quickcheck/Quickcheck2. -- All functions beginning with case_, prop_ or test_ will be extracted. -- -- > -- file SomeModule.hs -- > fooTestGroup = $(testGroupGenerator) -- > main = defaultMain [fooTestGroup] -- > case_1 = do 1 @=? 1 -- > case_2 = do 2 @=? 2 -- > prop_p xs = reverse (reverse xs) == xs -- > where types = xs :: [Int] -- -- is the same as -- -- > -- file SomeModule.hs -- > fooTestGroup = testGroup "SomeModule" [testProperty "p" prop_1, testCase "1" case_1, testCase "2" case_2] -- > main = defaultMain [fooTestGroup] -- > case_1 = do 1 @=? 1 -- > case_2 = do 2 @=? 2 -- > prop_1 xs = reverse (reverse xs) == xs -- > where types = xs :: [Int] testGroupGenerator :: ExpQ testGroupGenerator = [| testGroup $(locationModule) $ $(propListGenerator) ++ $(caseListGenerator) ++ $(testListGenerator) |] listGenerator :: String -> String -> ExpQ listGenerator beginning funcName = functionExtractorMap beginning (applyNameFix funcName) propListGenerator :: ExpQ propListGenerator = listGenerator "^prop_" "testProperty" caseListGenerator :: ExpQ caseListGenerator = listGenerator "^case_" "testCase" testListGenerator :: ExpQ testListGenerator = listGenerator "^test_" "testGroup" -- | The same as -- e.g. \n f -> testProperty (fixName n) f applyNameFix :: String -> ExpQ applyNameFix n = do fn <- [|fixName|] return $ LamE [VarP (mkName "n")] (AppE (VarE (mkName n)) (AppE fn (VarE (mkName "n")))) fixName :: String -> String fixName name = replace '_' ' ' $ drop 5 name replace :: Eq a => a -> a -> [a] -> [a] replace b v = map (\i -> if b == i then v else i)