rowan.a.tl/HushGP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleaned up tests!

Browse Source
This commit is contained in:
Taylor 2025-01-16 12:27:10 -06:00
parent 73c5cce879
commit 6fa6035739
3 changed files with 21 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -2,6 +2,7 @@
A PushGP implementation in Haskell A PushGP implementation in Haskell
## Tasks ## Tasks
* [ ] refactor Gene to contain *Gene to Gene* for naming consistency.
* [x] Do test-driven development on this one. * [x] Do test-driven development on this one.
* [x] Write tests for every function. * [x] Write tests for every function.
* [x] tests/ are just copied from make-grade, need to write for this project. * [x] tests/ are just copied from make-grade, need to write for this project.

3
tests/.ghci Normal file
View File

@ -0,0 +1,3 @@
:set stop :list
:set prompt "\ESC[1;34m%s \ESC[0;35mλ>\ESC[m "
:load Main ../src/Push ../src/GP

83
tests/Main.hs
View File

@ -1,76 +1,27 @@
import Control.Exception (assert) import Control.Exception (assert)
import qualified Data.Map as Map
import GP import GP
import Push import Push
import Test.Hspec
import Test.Hspec.QuickCheck
import Test.QuickCheck
exampleState = intTestFunc :: String -> [Int] -> [Gene] -> State -> IO ()
State intTestFunc name goal genome startState =
{ exec = [IntGene 5, StateFunc instructionParameterLoad, StateFunc instructionIntAdd], let state = loadProgram genome startState
int = [2, 6, 3], in assert (goal == int (interpretExec state)) putStrLn (name ++ " passed test.")
float = [1.2, 1.7],
bool = [True, False],
string = ["Hello", "Push"],
parameter = [IntGene 1, StringGene "Hi", BoolGene True, FloatGene 1.3],
input = Map.fromList [("in0", IntGene 1)]
}
prop_test1 :: [Int] -> Bool
prop_test1 nums = nums == reverse (reverse nums)
main :: IO () main :: IO ()
main = do main = do
quickCheck prop_test1 intTestFunc "instructionIntAdd" [8] [IntGene 6, IntGene 2, StateFunc instructionIntAdd] emptyState
assert ([8, 3] == int (instructionIntAdd exampleState)) putStrLn "Add test pass" intTestFunc "instructionIntSub" [4] [IntGene 6, IntGene 2, StateFunc instructionIntSub] emptyState
assert ([4, 3] == int (instructionIntSub exampleState)) putStrLn "Sub test pass" intTestFunc "instructionIntMul" [12] [IntGene 6, IntGene 2, StateFunc instructionIntMul] emptyState
assert ([12, 3] == int (instructionIntMul exampleState)) putStrLn "Mult test pass" intTestFunc "instructionIntDiv" [3] [IntGene 6, IntGene 2, StateFunc instructionIntDiv] emptyState
assert ([3, 3] == int (instructionIntDiv exampleState)) putStrLn "Div test pass" intTestFunc "instructionExecIf" [6, 5] [BoolGene True, StateFunc instructionExecIf, Block [IntGene 5, IntGene 6], Block [IntGene 7, IntGene 8]] emptyState
assert ([6, 2, 6, 3] == int (interpretExec exampleState)) putStrLn "Interpret test pass" intTestFunc "instructionExecDup" [8] [StateFunc instructionExecDup, IntGene 4, StateFunc instructionIntAdd] emptyState
intTestFunc "instructionExecDup" [12] [IntGene 2, Block [IntGene 4, IntGene 1, StateFunc instructionExecDoRange], StateFunc instructionIntAdd] emptyState
let loadedState = loadProgram [IntGene 6, IntGene 6, StateFunc instructionIntAdd] emptyState intTestFunc "instructionExecDoCount" [8] [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoCount], StateFunc instructionIntAdd] emptyState
assert ([12] == int (interpretExec loadedState)) putStrLn "Interpret test 2 pass" intTestFunc "instructionIntAdd" [69, 69, 69, 69, 2] [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoTimes], IntGene 69] emptyState
intTestFunc "instructionExecDoTimes" [70, 70] [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecWhile, IntGene 70] emptyState
let loadedState = loadProgram [BoolGene True, StateFunc instructionExecIf, Block [IntGene 5, IntGene 6], Block [IntGene 7, IntGene 8]] emptyState intTestFunc "instructionExecWhile" [70, 70, 70] [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecDoWhile, IntGene 70] emptyState
assert ([6, 5] == int (interpretExec loadedState)) putStrLn "execIf" intTestFunc "instructionExecDoWhile" [71] [BoolGene True, StateFunc instructionExecWhen, IntGene 71] emptyState
let loadedState = loadProgram [BoolGene False, StateFunc instructionExecIf, Block [IntGene 5, IntGene 6], Block [IntGene 7, IntGene 8]] emptyState
assert ([8, 7] == int (interpretExec loadedState)) putStrLn "execIf"
let loadedState = loadProgram [BoolGene False, PlaceInput "in0", StateFunc instructionIntAdd] exampleState
assert ([3, 6, 3] == int (interpretExec loadedState)) putStrLn "input map"
let loadedState = interpretExec $ loadProgram [StateFunc instructionExecDup, IntGene 2] emptyState
assert (int loadedState !! 0 == 2 && int loadedState !! 1 == 2) putStrLn "execDup"
let loadedState = loadProgram [IntGene 2, Block [IntGene 4, IntGene 1, StateFunc instructionExecDoRange], StateFunc instructionIntAdd] emptyState
assert ([12] == int (interpretExec loadedState)) putStrLn "execDoRange"
let loadedState = loadProgram [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoCount], StateFunc instructionIntAdd] emptyState
assert ([8] == int (interpretExec loadedState)) putStrLn "execDoCount"
let loadedState = loadProgram [IntGene 2, Block [IntGene 4, StateFunc instructionExecDoTimes], IntGene 69] emptyState
assert ([69, 69, 69, 69, 2] == int (interpretExec loadedState)) putStrLn "execDoTimes"
let loadedState = loadProgram [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecWhile, IntGene 70] emptyState
assert ([70, 70] == int (interpretExec loadedState)) putStrLn "execWhile"
let loadedState = loadProgram [BoolGene False, BoolGene True, BoolGene True, StateFunc instructionExecDoWhile, IntGene 70] emptyState
assert ([70, 70, 70] == int (interpretExec loadedState)) putStrLn "execDoWhile"
let loadedState = loadProgram [BoolGene False, StateFunc instructionExecWhen, IntGene 71] emptyState let loadedState = loadProgram [BoolGene False, StateFunc instructionExecWhen, IntGene 71] emptyState
assert (emptyState == interpretExec loadedState) putStrLn "execWhen" assert (emptyState == interpretExec loadedState) putStrLn "instructionExecWhen passed test."
let loadedState = loadProgram [BoolGene True, StateFunc instructionExecWhen, IntGene 71] emptyState
assert ([71] == int (interpretExec loadedState)) putStrLn "execWhen"
hspec $ do
describe "Prelude.read" $ do
it "can parse integers" $ do
read "10" `shouldBe` (10 :: Int)
describe "read" $ do
it "is inverse to show" $
property $
\x -> (read . show) x `shouldBe` (x :: Int)