Merge pull request #2 from 0xpantera/test/driver

0xpantera · web-flow · commit 498833cf85ab · 2024-11-25T12:27:20.000+01:00
Add comprehensive test suite
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -34,4 +34,16 @@
 ### Changed
 - Compiler pipeline now includes TACKY transformation stage
 - Assembly generation now works from TACKY rather than directly from AST
-- Parser improved to handle nested expressions correctly
+- Parser improved to handle nested expressions correctly
+
+## 0.2.1.0 -- 2024-11-25
+
+### Added
+- Comprehensive test suite with Hspec and Tasty
+- Unit tests for all compiler stages:
+  - Lexer tests
+  - Parser tests
+  - TACKY generation tests 
+  - Assembly generation tests
+  - Full pipeline integration tests
+- Test utilities and helper functions in Test.Common
diff --git a/README.md b/README.md
@@ -65,40 +65,47 @@ Programs are represented internally using a series of increasingly lower-level d
 
 ## Project Structure
 
-```
-.
-├── app/                           # Application entry point
-│   └── Main.hs
-├── bin/                           # Binary outputs
-├── lib/                           # Main library code
-│   ├── Halcyon.hs                 # Library entry point
-│   └── Halcyon/                   # Core modules
-│       ├── Backend/               # Code generation and emission
-│       │   ├── Codegen.hs         # TACKY to Assembly conversion
-│       │   ├── Emit.hs            # Assembly to text output
-│       │   └── ReplacePseudos.hs  # Register/stack allocation
-│       ├── Core/                  # Core data types and utilities
-│       │   ├── Assembly.hs        # Assembly representation
-│       │   ├── Ast.hs             # C language AST
-│       │   ├── Monad.hs           # Compiler monad stack
-│       │   ├── Settings.hs        # Compiler settings and types
-│       │   ├── Tacky.hs           # TACKY IR definition
-│       │   └── TackyGen.hs        # AST to TACKY transformation
-│       ├── Driver/                # Compiler driver
-│       │   ├── Cli.hs             # Command line interface
-│       │   └── Pipeline.hs        # Compilation pipeline
-│       └── Frontend/              # Parsing and analysis
-│           ├── Lexer.hs           # Lexical analysis
-│           ├── Parse.hs           # Parsing
-│           └── Tokens.hs          # Token definitions
-├── test/                          # Test suite
-│   └── Main.hs
-├── CHANGELOG.md                   # Version history
-├── LICENSE                        # Project license
-├── README.md                      # Project documentation
-├── flake.nix                      # Nix build configuration
-└── halcyon.cabal                  # Cabal build configuration
-```
+  ```
+  .
+  ├── app/                           # Application entry point
+  │   └── Main.hs
+  ├── bin/                           # Binary outputs
+  ├── lib/                           # Main library code
+  │   ├── Halcyon.hs                 # Library entry point
+  │   └── Halcyon/                   # Core modules
+  │       ├── Backend/               # Code generation and emission
+  │       │   ├── Codegen.hs         # TACKY to Assembly conversion
+  │       │   ├── Emit.hs            # Assembly to text output
+  │       │   └── ReplacePseudos.hs  # Register/stack allocation
+  │       ├── Core/                  # Core data types and utilities
+  │       │   ├── Assembly.hs        # Assembly representation
+  │       │   ├── Ast.hs             # C language AST
+  │       │   ├── Monad.hs           # Compiler monad stack
+  │       │   ├── Settings.hs        # Compiler settings and types
+  │       │   ├── Tacky.hs           # TACKY IR definition
+  │       │   └── TackyGen.hs        # AST to TACKY transformation
+  │       ├── Driver/                # Compiler driver
+  │       │   ├── Cli.hs             # Command line interface
+  │       │   └── Pipeline.hs        # Compilation pipeline
+  │       └── Frontend/              # Parsing and analysis
+  │           ├── Lexer.hs           # Lexical analysis
+  │           ├── Parse.hs           # Parsing
+  │           └── Tokens.hs          # Token definitions
+  ├── test/                          # Test suite
+  │   ├── Main.hs
+  │   └── Test/
+  │       ├── Lexer.hs
+  │       ├── Parser.hs
+  │       ├── Tacky.hs
+  │       ├── Assembly.hs
+  │       ├── Pipeline.hs
+  │       └── Common.hs
+  ├── CHANGELOG.md                   # Version history
+  ├── LICENSE                        # Project license
+  ├── README.md                      # Project documentation
+  ├── flake.nix                      # Nix build configuration
+  └── halcyon.cabal                  # Cabal build configuration
+  ```
 
 ### Architecture
 
@@ -147,6 +154,37 @@ cabal run halcyon -- input.c
 cabal run halcyon -- --lex input.c
 ```
 
+## Testing
+
+Halcyon uses Hspec and Tasty for its test suite. The tests cover all stages of compilation:
+
+```bash
+# Run all tests
+cabal test
+
+# Run tests with output
+cabal test --test-show-details=direct
+
+# Run a specific test module
+cabal test --test-pattern "Lexer"
+```
+
+The test suite includes:
+
+- Unit tests for each compiler stage
+- Integration tests for the full pipeline
+- Helper utilities for building test cases
+
+Tests are organized by compiler stage in `test/Test/`:
+
+- `Lexer.hs`: Token generation
+- `Parser.hs`: AST construction
+- `Tacky.hs`: TACKY IR generation
+- `Assembly.hs`: Assembly generation
+- `Pipeline.hs`: Full compilation pipeline
+- `Common.hs`: Shared test utilities
+
+
 ## External Dependencies
 
 Halcyon relies on the following system tools:
@@ -168,7 +206,7 @@ The compiler provides detailed error reporting for:
 
 ### The Basics
 - [x] A minimal compiler
-- [ ] Unary operators
+- [x] Unary operators
 - [ ] Binary operators
 - [ ] Logical and relational operators
 - [ ] Local variables
diff --git a/halcyon.cabal b/halcyon.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               halcyon
-version:            0.2.0.0
+version:            0.2.1.0
 -- synopsis:
 -- description:
 license:            BSD-3-Clause
@@ -19,13 +19,12 @@ common warnings
 library
     import:           warnings
     exposed-modules:
-        Halcyon
-    other-modules:
-          Halcyon.Core.Settings
+          Halcyon
+        , Halcyon.Core.Settings
         , Halcyon.Core.Ast
         , Halcyon.Core.Assembly
         , Halcyon.Core.Monad
-        , Halcyon.Core.Tacky
+        , Halcyon.Core.Tacky 
         , Halcyon.Core.TackyGen
         , Halcyon.Frontend.Lexer
         , Halcyon.Frontend.Parse
@@ -35,6 +34,7 @@ library
         , Halcyon.Backend.ReplacePseudos
         , Halcyon.Driver.Cli
         , Halcyon.Driver.Pipeline
+    other-modules:
     -- other-extensions:
     build-depends:    base ^>=4.20.0.0
         , bytestring
@@ -65,11 +65,26 @@ executable halcyon
 test-suite halcyon-test
     import:           warnings
     default-language: GHC2024
-    -- other-modules:
+    other-modules:
+          Test.Lexer
+        , Test.Parser
+        , Test.Tacky
+        , Test.Assembly
+        , Test.Pipeline
     -- other-extensions:
     type:             exitcode-stdio-1.0
     hs-source-dirs:   test
     main-is:          Main.hs
     build-depends:
-        base ^>=4.20.0.0,
-        halcyon
+          base ^>=4.20.0.0
+        , halcyon
+        , tasty ^>=1.4
+        , tasty-hspec ^>=1.2
+        , tasty-hedgehog ^>=1.4
+        , tasty-golden ^>=2.3
+        , hedgehog ^>=1.4
+        , hspec ^>=2.11
+        , text
+        , megaparsec
+        , directory
+        , filepath
diff --git a/lib/Halcyon/Core/Ast.hs b/lib/Halcyon/Core/Ast.hs
@@ -3,21 +3,21 @@ module Halcyon.Core.Ast where
 import Data.Text ( Text )
 
 data Program = Program FunctionDef
-  deriving Show
+  deriving (Eq, Show)
 
 data FunctionDef = Function 
   { name :: Text
   , body :: Statement
-  } deriving Show
+  } deriving (Eq, Show)
 
 data Statement = Return Expr
-  deriving Show
+  deriving (Eq, Show)
 
 data Expr = Constant Int | Unary UnaryOp Expr
-  deriving Show
+  deriving (Eq, Show)
 
 data UnaryOp = Complement | Negate
-  deriving Show
+  deriving (Eq, Show)
 
 -- Formal Grammar in EBNF
 -- <program> ::= <function>
diff --git a/test/Main.hs b/test/Main.hs
@@ -1,4 +1,28 @@
+{-# LANGUAGE OverloadedStrings #-}
 module Main (main) where
 
+import Test.Tasty ( defaultMain, testGroup )
+import Test.Tasty.Hspec ( testSpecs )
+
+import qualified Test.Lexer as Lex
+import qualified Test.Parser as Parse
+import qualified Test.Tacky as Tacky
+import qualified Test.Assembly as Asm
+import qualified Test.Pipeline as Pipeline
+
 main :: IO ()
-main = putStrLn "Test suite not yet implemented."
+main = do
+  specs <- concat <$> mapM testSpecs
+    [ Lex.lexerSpecs
+    , Parse.parserSpecs
+    , Tacky.tackySpecs  
+    , Asm.assemblySpecs
+    , Pipeline.pipelineSpecs
+    ]
+
+  defaultMain (testGroup "All Tests" [
+      testGroup "Specs" specs
+      -- Add property/golden tests later:
+      -- , testGroup "Properties" props
+      -- , testGroup "Golden Tests" goldens
+      ])
diff --git a/test/Test/Assembly.hs b/test/Test/Assembly.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Test.Assembly (assemblySpecs) where
+
+import Test.Hspec
+import Halcyon.Backend.Codegen (gen)
+import Halcyon.Core.Assembly qualified as Asm
+import Halcyon.Core.Tacky qualified as Tacky
+
+assemblySpecs :: Spec
+assemblySpecs = describe "Assembly Generation" $ do
+  it "generates assembly for simple return" $
+    let tacky = Tacky.Program $ Tacky.Function "main" [Tacky.Return (Tacky.Constant 42)]
+    in gen tacky `shouldBe` Asm.Program (Asm.Function "main" 
+         [ Asm.Mov (Asm.Imm 42) (Asm.Register Asm.Ax)
+         , Asm.Ret])
+
+  it "generates assembly for unary operation" $
+    let tacky = Tacky.Program $ Tacky.Function "main" 
+          [ Tacky.Unary Tacky.Negate (Tacky.Constant 42) (Tacky.Var "tmp.0")
+          , Tacky.Return (Tacky.Var "tmp.0")]
+    in gen tacky `shouldBe` Asm.Program (Asm.Function "main"
+         [ Asm.Mov (Asm.Imm 42) (Asm.Pseudo "tmp.0")
+         , Asm.Unary Asm.Neg (Asm.Pseudo "tmp.0")
+         , Asm.Mov (Asm.Pseudo "tmp.0") (Asm.Register Asm.Ax)
+         , Asm.Ret])
diff --git a/test/Test/Common.hs b/test/Test/Common.hs
@@ -0,0 +1,23 @@
+module Test.Common where
+
+import Halcyon.Core.Ast as Ast
+
+-- Smart constructors for building test cases
+makeMainFunction :: Statement -> Program
+makeMainFunction stmt = Program (Function "main" stmt)
+
+makeReturn :: Expr -> Statement 
+makeReturn = Return
+
+makeConstant :: Int -> Expr
+makeConstant = Constant
+
+makeUnary :: UnaryOp -> Int -> Expr
+makeUnary op n = Unary op (Constant n)
+
+-- Combining them for common cases
+simpleProgram :: Int -> Program
+simpleProgram n = makeMainFunction (makeReturn (makeConstant n))
+
+unaryProgram :: UnaryOp -> Int -> Program
+unaryProgram op n = makeMainFunction (makeReturn (makeUnary op n))
diff --git a/test/Test/Lexer.hs b/test/Test/Lexer.hs
@@ -0,0 +1,32 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Test.Lexer (lexerSpecs) where
+
+import Test.Hspec
+import Text.Megaparsec (parse)
+import Halcyon.Frontend.Lexer (lexer)
+import Halcyon.Frontend.Tokens
+
+lexerSpecs :: Spec 
+lexerSpecs = describe "Lexer" $ do
+  describe "basic tokens" $ do
+    it "lexes empty input" $
+      parse lexer "" "" `shouldParse` []
+      
+    it "lexes simple return" $
+      parse lexer "" "return 42;" `shouldParse` 
+        [TokReturn, TokNumber 42, TokSemicolon]
+
+  describe "unary operators" $ do
+    it "lexes negation" $
+      parse lexer "" "-42" `shouldParse`
+        [TokHyphen, TokNumber 42]
+        
+    it "lexes complement" $
+      parse lexer "" "~42" `shouldParse`
+        [TokTilde, TokNumber 42]
+
+
+-- Helper for cleaner parse result assertions  
+shouldParse :: (Eq a, Show a, Show e) => Either e a -> a -> Expectation
+shouldParse (Right got) expected = got `shouldBe` expected
+shouldParse (Left err) _ = expectationFailure $ show err
diff --git a/test/Test/Parser.hs b/test/Test/Parser.hs
@@ -0,0 +1,19 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Test.Parser (parserSpecs) where
+
+import Test.Hspec
+import Halcyon.Frontend.Parse (parseTokens)
+import Halcyon.Frontend.Tokens
+import Halcyon.Core.Ast
+
+parserSpecs :: Spec
+parserSpecs = describe "Parser" $ do
+  it "parses minimal program" $
+    parseTokens [TokInt, TokIdent "main", TokLParen, TokVoid, TokRParen, 
+                TokLBrace, TokReturn, TokNumber 42, TokSemicolon, TokRBrace]
+    `shouldBe` Right (Program (Function "main" (Return (Constant 42))))
+
+  it "parses unary negation" $
+    parseTokens [TokInt, TokIdent "main", TokLParen, TokVoid, TokRParen,
+                TokLBrace, TokReturn, TokHyphen, TokNumber 42, TokSemicolon, TokRBrace]
+    `shouldBe` Right (Program (Function "main" (Return (Unary Negate (Constant 42)))))
diff --git a/test/Test/Pipeline.hs b/test/Test/Pipeline.hs
diff --git a/test/Test/Tacky.hs b/test/Test/Tacky.hs
