oughta: Rename from FileCheck

Author: langston-barrett

.github/workflows/ci.yaml

@@ -67,19 +67,19 @@ jobs:
         (cd grease-cli && cabal check)
         (cd doc/diagrams && cabal check)
         (cd elf-edit-core-dump && cabal check)
-        (cd filecheck && cabal check)
+        (cd oughta && cabal check)
 
     - name: Configure build
       shell: bash
       run: cabal configure --enable-tests
 
-    - name: Build FileCheck
+    - name: Build Oughta
       shell: bash
-      run: cabal build pkg:filecheck
+      run: cabal build pkg:oughta
 
-    - name: Test FileCheck
+    - name: Test Oughta
       shell: bash
-      run: cabal test pkg:filecheck
+      run: cabal test pkg:oughta
 
     - name: Build grease-cli
       shell: bash
@@ -106,7 +106,7 @@ jobs:
       # identifiers from library dependencies. Since we are only building
       # Haddocks to ensure well-formedness, we consider this an acceptable
       # tradeoff.
-      run: cabal haddock --disable-documentation pkg:grease pkg:grease-cli pkg:elf-edit-core-dump pkg:filecheck
+      run: cabal haddock --disable-documentation pkg:grease pkg:grease-cli pkg:elf-edit-core-dump pkg:oughta
 
     - name: Save cache store cache
       uses: actions/cache/save@v4

.github/workflows/lint.yml

@@ -22,4 +22,4 @@ jobs:
             https://github.com/ndmitchell/hlint/releases/download/v3.8/hlint-3.8-x86_64-linux.tar.gz
           tar xvf hlint.tar.gz
 
-          ./hlint-3.8/hlint grease{,-aarch32,-ppc,-x86}/src grease-cli/{main,src,tests} filecheck/{src,test}
+          ./hlint-3.8/hlint grease{,-aarch32,-ppc,-x86}/src grease-cli/{main,src,tests} oughta/{src,test}

cabal.project

@@ -6,7 +6,7 @@ packages:
   grease-x86/grease-x86.cabal
   doc/diagrams/grease-diagrams.cabal
   elf-edit-core-dump
-  filecheck/filecheck.cabal
+  oughta/oughta.cabal
 
   deps/macaw/base/
   deps/macaw/crucible-macaw-debug/

doc/dev.md

@@ -68,7 +68,7 @@ As always, see `--help` for more options.
 We treat a small number of hlint warnings as errors in CI. To run hlint locally, try:
 
 ```sh
-hlint grease{,-aarch32,-ppc,-x86}/src grease-cli/{main,src,tests} filecheck/{src,test}
+hlint grease{,-aarch32,-ppc,-x86}/src grease-cli/{main,src,tests} oughta/{src,test}
 ```
 
 ## Source code

grease-cli/grease-cli.cabal

@@ -201,12 +201,12 @@ test-suite grease-tests
     , containers
     , crucible-llvm
     , directory
-    , filecheck
     , filepath
     , hedgehog
     , lumberjack
     , macaw-base
     , optparse-applicative
+    , oughta
     , parameterized-utils
     , prettyprinter
     , tasty

grease-cli/tests/Main.hs

@@ -49,7 +49,7 @@ import Control.Monad.IO.Class (MonadIO, liftIO)
 
 import qualified Options.Applicative as Opt
 
-import FileCheck qualified as FileCheck
+import Oughta qualified as Ota
 import qualified Lumberjack as LJ
 
 import qualified Test.Tasty as T
@@ -504,7 +504,7 @@ llvmTests = do
             res <- simulateLlvmSyntax opts la'
             logResults la' res
         Text.IO.writeFile (FilePath.replaceExtension path "out") logTxt
-        let output = FileCheck.Output (Text.encodeUtf8 logTxt)
+        let output = Ota.Output (Text.encodeUtf8 logTxt)
         let prelude =
               Text.unlines
               [ "function ok() check 'All goals passed!' end"
@@ -515,13 +515,13 @@ llvmTests = do
               , "end"
               , "function no_heuristic() check 'Unable to find a heuristic for any goal' end"
               ]
-        let prog0 = FileCheck.fromLineComments path ";; " content
-        let prog = FileCheck.addPrefix prelude prog0
-        FileCheck.Result r <- FileCheck.check prog output
+        let prog0 = Ota.fromLineComments path ";; " content
+        let prog = Ota.addPrefix prelude prog0
+        Ota.Result r <- Ota.check prog output
         case r of
           Left f -> throwIO f
           Right s ->
-            let ms = FileCheck.successMatches s in
+            let ms = Ota.successMatches s in
             T.U.assertBool "Test has some assertions" (not (Seq.null ms))
 
 llvmBcTests :: T.TestTree

filecheck/LICENSE oughta/LICENSEfilecheck/LICENSE renamed to oughta/LICENSE

@@ -1,16 +1,19 @@
-# FileCheck
+# Oughta
 
 ## Overview
 
-FileCheck is a Haskell library inspired by the [command-line tool of the same
-name][llvm]. It is used to test programs that output text. The testing paradigm
-essentially combines golden testing with `grep`.
+Oughta is a Haskell library for testing programs that output text. The testing
+paradigm essentially combines golden testing with `grep`.
 
-[llvm]: https://llvm.org/docs/CommandGuide/FileCheck.html
+Oughta draws inspiration from LLVM's [FileCheck] and Rust's [compiletest].
 
-More precisely, FileCheck allows you to build parsers for the output of your
-program. The inputs to FileCheck are the output of the program under test and a
-separate, generally quite short program written in the FileCheck parsing DSL.
+[FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
+[compiletest]: https://rustc-dev-guide.rust-lang.org/tests/compiletest.html 
+
+More precisely, Oughta provides a DSL to build *recognizers* (i.e., parsers that
+simply accept or reject an string). The inputs to Oughta are a string (usually,
+the output of the program under test) and a separate, generally quite short
+program written in the Oughta DSL.
 
 The simplest DSL procedure is `check`, which checks that the output contains a
 string. For example, the following test would pass:
@@ -28,10 +31,10 @@ check "world"
 ## Example
 
 Let's say that you have decided to write the first ever Haskell implementation
-of a POSIX shell, `hsh`. Here's how to test it with FileCheck.
+of a POSIX shell, `hsh`. Here's how to test it with Oughta.
 
 If the input to the program under test is a file format that supports comments,
-it is often convenient to embed FileCheck DSL programs in the input itself. For
+it is often convenient to embed Oughta DSL programs in the input itself. For
 example, here's a test for `echo`:
 
 ```sh
@@ -48,7 +51,7 @@ module Main (main) where
 
 import Control.Monad (filterM, forM)
 import Data.ByteString qualified as BS
-import FileCheck qualified as FC
+import Oughta qualified
 import System.Directory qualified as Dir
 import Test.Tasty.HUnit qualified as TTH
 import Test.Tasty qualified as TT
@@ -63,9 +66,9 @@ test sh = do
   content <- BS.readFile sh
   (stdout, _stderr) <- runScript content
   let comment = "# "  -- shell script start-of-line comment
-  let prog = FC.fromLineComments sh comment content
-  result <- FC.check prog (FC.Output stdout)
-  TTH.assertBool (sh ++ " contained some assertions") (not (FC.resultNull result))
+  let prog = Oughta.fromLineComments sh comment content
+  result <- Oughta.check prog (Oughta.Output stdout)
+  TTH.assertBool (sh ++ " contained some assertions") (not (Oughta.resultNull result))
 
 main :: IO ()
 main = do
@@ -88,16 +91,16 @@ test :: FilePath -> IO ()
 test sh = do
   -- snip --
   let stdoutComment = "# STDOUT: "
-  let prog = FC.fromLineComments sh stdoutComment content
-  stdoutResult <- FC.check prog (FC.Output stdout)
+  let prog = Oughta.fromLineComments sh stdoutComment content
+  stdoutResult <- Oughta.check prog (Oughta.Output stdout)
 
   let stderrComment = "# STDERR: "
-  let prog' = FC.fromLineComments sh stderrComment content
-  stderrResult <- FC.check prog' (FC.Output stderr)
+  let prog' = Oughta.fromLineComments sh stderrComment content
+  stderrResult <- Oughta.check prog' (Oughta.Output stderr)
 
   TTH.assertBool
     (sh ++ " contained some assertions")
-    (not (FC.resultNull stdoutResult && FC.resultNull stderrResult))
+    (not (Oughta.resultNull stdoutResult && Oughta.resultNull stderrResult))
 ```
 
 Test cases would then look like so:
@@ -111,8 +114,8 @@ echo 'Hello, stderr!' 1>&2
 
 ## Cookbook
 
-This section demonstrates how to accomplish common tasks with the FileCheck DSL.
-The FileCheck DSL is just [Lua][lua], extended with an API for easy parsing.
+This section demonstrates how to accomplish common tasks with the Oughta DSL.
+The DSL is just [Lua][lua], extended with an API for easy parsing.
 
 [Lua]: https://www.lua.org/ 
 
@@ -122,7 +125,7 @@ as simple as possible, and some repetition should be accepted for the sake of
 readability. It is often appropriate to just make a sequence of API calls with
 literal strings as arguments.
 
-FileCheck is used to test itself. See the test suite for additional examples.
+Oughta is used to test itself. See the test suite for additional examples.
 
 ### Long matches
 
@@ -156,7 +159,7 @@ check("I'm sorry, " .. name)
 ```
 or with a `for`-loop:
 ```
-Step 1: Learn about FileCheck
+Step 1: Learn about Oughta
 Step 2: Use it to test your project
 Step 3: Enjoy!
 ```
@@ -190,7 +193,7 @@ The Lua API is *stateful*. It keeps track of a global variable `text` that
 is initialized to the output of the program under test. Various API functions
 cause the API to seek forward in `text`. This is analogous to working file-like
 objects in languages like C or Python. `text` should not be updated from Lua
-code; such updates will be ignored by FileCheck.
+code; such updates will be ignored by Oughta.
 
 ### High-level API
 
@@ -219,24 +222,24 @@ Other utilities:
 
 ## Motivation
 
-The overall FileCheck paradigm is a form of [data driven testing]. See that blog
+The overall Oughta paradigm is a form of [data driven testing]. See that blog
 post for considerable motivation and discussion.
 
 [data driven testing]: https://matklad.github.io/2021/05/31/how-to-test.html#Data-Driven-Testing
 
-In comparison to golden testing, FileCheck-style tests are *coarser*. They only
+In comparison to golden testing, Oughta-style tests are *coarser*. They only
 check particular parts of the program's output. This can cause less churn in
 the test suite when the program output changes in ways that are not relevant
 to the properties being tested. The fineness of golden testing can force
 devlopers to adopt [complex] [workarounds], these can sometimes be obviated by
-FileCheck-style testing.
+Oughta-style testing.
 
 [complex]: https://rustc-dev-guide.rust-lang.org/tests/ui.html#normalization 
 [workarounds]: https://github.com/GaloisInc/crucible/blob/dc0895f4435dc19a8cceee3272c9a508221bce51/crux-llvm/test/Test.hs#L226-L311
 
-However, it is more complex. For example, it requires learning the FileCheck
-DSL. It can also cause unexpected successes, e.g., if the program output
-contains the pattern being checked, but not in the proper place.
+However, it is more complex. For example, it requires learning the Oughta DSL.
+It can also cause unexpected successes, e.g., if the program output contains the
+pattern being checked, but not in the proper place.
 
 Why build a Haskell library when LLVM already provides their FileCheck tool?
 There are a variety of reasons:

filecheck/README.md oughta/README.mdfilecheck/README.md renamed to oughta/README.md

@@ -1,26 +1,26 @@
 cabal-version: 2.4
-name: filecheck
+name: oughta
 version: 0.1.0.0
 author: Galois, Inc.
 maintainer: grease@galois.com
 copyright: Galois, Inc. 2025
 license: BSD-3-Clause
 license-file: LICENSE
-synopsis: Like LLVM's FileCheck tool, but as a Haskell library.
+synopsis: A library to test programs that output text.
 description:
-  Like LLVM's FileCheck tool, but as a Haskell library.
+  A library to test programs that output text.
 
-  See upstream docs for details.
+  See the README for details.
 extra-doc-files:
   README.md
 extra-source-files:
-  src/FileCheck/filecheck.lua
+  src/Oughta/oughta.lua
 category: Testing
 
 source-repository head
   type: git
   location: https://github.com/GaloisInc/grease
-  subdir: filecheck
+  subdir: oughta
 
 common shared
   default-language: GHC2021
@@ -134,23 +134,23 @@ library
     text,
 
   exposed-modules:
-    FileCheck
+    Oughta
   other-modules:
-    FileCheck.Exception
-    FileCheck.Extract
-    FileCheck.Lua
-    FileCheck.LuaApi
-    FileCheck.Pos
-    FileCheck.Result
-    FileCheck.Traceback
+    Oughta.Exception
+    Oughta.Extract
+    Oughta.Lua
+    Oughta.LuaApi
+    Oughta.Pos
+    Oughta.Result
+    Oughta.Traceback
 
-test-suite filecheck-tests
+test-suite oughta-tests
   import: shared
   type: exitcode-stdio-1.0
   hs-source-dirs: test
-  build-depends:
-    filecheck
   main-is: Test.hs
+  build-depends:
+    oughta
   build-depends:
     bytestring,
     directory,