RackUnit

https://docs.racket-lang.org/rackunit/
Admin
RackUnit is a unit-testing framework for Racket designed to handle the needs of all programmers,...
Tokens:22,745
Snippets:230
Trust Score:9.4
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Running a Dummy Test Suite

Source: https://docs.racket-lang.org/rackunit/internals.html

Demonstrates how to use `run-test` with a `test-suite` containing a `test-case` that checks for equality.

```racket
(run-test 
(test-suite 
"Dummy" 
(test-case "Dummy" (check-equal? 1 2))))
```

--------------------------------

### Import RackUnit and test file

Source: https://docs.racket-lang.org/rackunit/quick-start.html

Imports the RackUnit testing framework and the code file to be tested. This is the initial setup for writing tests.

```racket
#lang racket/base

(require rackunit  
         "file.rkt")
```

--------------------------------

### dynamic-require/expose

Source: https://docs.racket-lang.org/rackunit/api.html

Similar to dynamic-require, but gets internal bindings like require/expose.

```APIDOC
## dynamic-require/expose mod name → any

### Description
Like `dynamic-require`, but gets internal bindings like `require/expose`.

### Parameters
* **mod** (`or/c module-path? module-path-index? resolved-module-path?`) - The module to require from.
* **name** (`symbol?`) - The name of the binding to retrieve.
```

--------------------------------

### Use a Binary Custom Check with a Predicate

Source: https://docs.racket-lang.org/rackunit/api.html

Example of using the check-char=? binary custom check.

```racket
(check-char=? (read-char (open-input-string "a")) #\a)
```

--------------------------------

### Standard Check Failure Example

Source: https://docs.racket-lang.org/rackunit/api.html

Illustrates a standard check failure for check-equal?, showing the name, location, actual, and expected values.

```racket
(check-equal? 0 1)
```

--------------------------------

### Test Control Flow

Source: https://docs.racket-lang.org/rackunit/api.html

Utilities for managing the execution flow of tests, including setup, teardown, and delayed execution.

```APIDOC
## Test Control Flow

### Description
Utilities for managing the execution flow of tests.

### Control Flow Functions
- `before`
- `after`
- `around`
- `delay-test`
```

--------------------------------

### Count Successful Tests Using fold-test-results

Source: https://docs.racket-lang.org/rackunit/internals.html

Example of using `fold-test-results` to count the number of successful test cases by checking the result type.

```racket
(define (count-successes test)
(fold-test-results
(lambda (result seed)
(if (test-success? result)
(add1 seed)
seed))
0
test))
```

--------------------------------

### Fold Test Results with Custom Actions

Source: https://docs.racket-lang.org/rackunit/internals.html

The `fold-test-results` procedure applies a function to each test result, accumulating a seed value. It allows custom setup and teardown actions for test suites.

```racket
procedure| (fold-test-results|  | result-fn|  |  |  |   
>> ---|---|---|---|---|---|---
|  | seed|  |  |  |   
|  | test|  |  |  |   
|  | #:run run|  |  |  |   
|  | #:fdown fdown|  |  |  |   
|  | #:fup fup)|  | →|  | 'a
```

--------------------------------

### Simple Equality Check in RackUnit

Source: https://docs.racket-lang.org/rackunit/philosophy.html

Use for purely functional programs where tests are independent and typically check for equality. No special setup is required.

```racket
(check-equal? (length null) 0)
```

```racket
(check-equal? (length '(a)) 1)
```

```racket
(check-equal? (length '(a b)) 2)
```

--------------------------------

### Use a Simple Custom Check

Source: https://docs.racket-lang.org/rackunit/api.html

Demonstrates the usage of a simple custom check, check-odd?, and shows a failure case.

```racket
(check-odd? 3)
```

```racket
(check-odd? 2)
```

--------------------------------

### Define a Test Suite with Before/After Hooks

Source: https://docs.racket-lang.org/rackunit/api.html

Constructs a test suite with a name, optional before and after thunks, and a list of tests. The before-thunk runs before tests, and after-thunk runs after. This is not immediately run; use separate functions for execution.

```racket
(test-suite 
"An example suite"
 #:before (lambda () (display "Before"))
 #:after (lambda () (display "After"))
 (test-case 
"An example test"
 (check-eq? 1 1))
 (test-suite "A nested test suite"
 (test-case "Another test"
 (check < 1 2))))
```

--------------------------------

### Create a GUI Test Runner Procedure

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a new RackUnit GUI window and returns a procedure that runs the given tests and displays the results in the GUI.

```racket
(make-gui-runner)

```

--------------------------------

### Get Current Test Invocation Directory with current-test-invocation-directory

Source: https://docs.racket-lang.org/rackunit/Testing_Utilities.html

This parameter retrieves the directory where the current test is being invoked. It re-exports `current-test-invocation-directory` from `raco/testing`.

```Racket
(current-test-invocation-directory)
```

--------------------------------

### Create a Test Suite from a List of Tests

Source: https://docs.racket-lang.org/rackunit/api.html

Constructs a test suite with a given name and a list of tests. It also supports optional before and after thunks. Unlike the `test-suite` form, tests are provided as a list.

```racket
(make-test-suite
 "A suite name"
 (list (test-case "A test" (check true)))
 #:before (lambda () (print "Setup"))
 #:after (lambda () (print "Teardown")))
```

--------------------------------

### Use a General Custom Check

Source: https://docs.racket-lang.org/rackunit/api.html

Demonstrates the usage of the check-even? general custom check and shows a failure case.

```racket
(check-even? 0)
```

```racket
(check-even? 1)
```

--------------------------------

### Run Tests with RackUnit GUI

Source: https://docs.racket-lang.org/rackunit/api.html

Launches a new RackUnit GUI window and runs the provided tests. When `wait?` is true, the procedure blocks until the GUI window is closed.

```racket
#lang racket

(require rackunit rackunit/gui)

(test/gui
 (test-suite
  "all tests"
  (test-suite
   "math tests"
   (test-case "addition" (check-equal? (+ 1 1) 2))
   (test-case "subtraction" (check-equal? (- 0 0) 0))
   (test-case "multiplication" (check-equal? (* 2 2) 5)))
  (test-suite
   "string tests"
   (test-case "append" (check-equal? (string-append "a" "b") "ab"))
   (test-case "ref" (check-equal? (string-ref "abc" 1) #\b)))))

```

--------------------------------

### Define and Bind a Test Suite

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test suite with the given name (converted to a string) and tests, and binds it to the same name. This simplifies the process of creating and referencing test suites.

```racket
(define-test-suite example-suite 
 (check = 1 1))
```

--------------------------------

### make-gui-runner

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a new RackUnit GUI window and returns a procedure that, when applied, runs the given tests and displays the results in the GUI.

```APIDOC
## make-gui-runner

### Description
Creates a new RackUnit GUI window and returns a procedure that, when applied, runs the given tests and displays the results in the GUI.

### Signature
procedure(make-gui-runner) → (-> (or/c test-case? test-suite?) ... any)

### Parameters
This procedure does not take any direct parameters. It returns a procedure that accepts test cases or test suites.
```

--------------------------------

### test/gui

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a new RackUnit GUI window and runs each test. The GUI is updated as tests complete. When wait? is true, test/gui does not return until the test runner window has been closed.

```APIDOC
## test/gui

### Description
Creates a new RackUnit GUI window and runs each test. The GUI is updated as tests complete. When wait? is true, test/gui does not return until the test runner window has been closed.

### Signature
procedure(test/gui test ... [#:wait? wait?]) → void?

### Parameters
#### Path Parameters
- **test** (or/c test-case? test-suite?) - Required - The test case or test suite to run.
- **wait?** (boolean?) - Optional - If true, the function will not return until the GUI window is closed. Defaults to #f.

### Request Example
```racket
(require rackunit rackunit/gui)
(test/gui
  (test-suite
    "all tests"
    (test-suite
      "math tests"
      (test-case "addition" (check-equal? (+ 1 1) 2))
      (test-case "subtraction" (check-equal? (- 0 0) 0))
      (test-case "multiplication" (check-equal? (* 2 2) 5)))
    (test-suite
      "string tests"
      (test-case "append" (check-equal? (string-append "a" "b") "ab") )
      (test-case "ref" (check-equal? (string-ref "abc" 1) #\b)))))
```
```

--------------------------------

### Get the Implementation Name of a Check Transformer

Source: https://docs.racket-lang.org/rackunit/api.html

Use check-transformer-impl-name to retrieve the identifier that names the procedure implementing a check transformer. This procedure accepts the same arguments as the check form, plus #:location and #:exp keyword arguments.

```racket
(check-transformer-impl-name ct)
```

--------------------------------

### Using with-default-check-info* to manage check info

Source: https://docs.racket-lang.org/rackunit/api.html

Employ `with-default-check-info*` to add information to the check-info stack, ignoring any entries whose names already exist on the stack. This allows for default information that can be selectively overridden.

```racket
(with-default-check-info*
 (list (make-check-name 'first-name))
 (λ () 
 (with-default-check-info*
 (list (make-check-name 'last-name))
 (λ () 
 (check-true #false)))))
```

--------------------------------

### Define, Bind, and Provide a Test Suite

Source: https://docs.racket-lang.org/rackunit/api.html

Similar to `define-test-suite`, this form also provides the defined test suite. This is useful when the test suite needs to be accessible externally.

```racket
(define/provide-test-suite my-suite 
 (test-case "A simple test" (check true)))
```

--------------------------------

### Use Dynamic Info with Current Directory

Source: https://docs.racket-lang.org/rackunit/api.html

Shows how `dynamic-info` can capture the value of a parameter, such as `current-directory`, at the time of the check failure. The procedure provided to `dynamic-info` is called when the info is displayed.

```racket
(with-check-info (['current-dir (dynamic-info current-directory)])
  (check-equal? 1 2)
  (parameterize ([current-directory (find-system-path 'temp-dir)])
    (check-equal? 1 2)))
```

--------------------------------

### test-suite

Source: https://docs.racket-lang.org/rackunit/api.html

Constructs a test suite with a given name and tests. It can optionally include thunks to run before and after the tests.

```APIDOC
## test-suite

### Description
Constructs a test suite with the given name and tests. The tests may be checks, test cases, constructed using test-begin or test-case, or other test suites. The before-thunk and after-thunk are optional thunks (functions with no argument). They are run before and after the tests are run, respectively.

### Syntax
```
(test-suite name-expr maybe-before maybe-after test ...)
```

### Parameters
- `name-expr`: An expression that evaluates to the name of the test suite.
- `maybe-before`: Optional #:before thunk.
- `maybe-after`: Optional #:after thunk.
- `test`: One or more tests (checks, test cases, or other test suites).

### Example
```racket
(test-suite 
  "An example suite"
  #:before (lambda () (display "Before"))
  #:after (lambda () (display "After"))
  (test-case 
    "An example test"
    (check-eq? 1 1))
  (test-suite "A nested test suite"
    (test-case "Another test"
      (check < 1 2))))
```
```

--------------------------------

### define-test-suite

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test suite with the given name and tests, and binds it to the same name.

```APIDOC
## define-test-suite

### Description
Creates a test suite with the given name (converted to a string) and tests, and binds it to the same name.

### Syntax
```
(define-test-suite name test ...)
```

### Parameters
- `name`: The name for the test suite.
- `test`: One or more tests to include in the suite.

### Example
```racket
(define-test-suite example-suite  
  (check = 1 1))
```
```

--------------------------------

### make-test-suite

Source: https://docs.racket-lang.org/rackunit/api.html

Constructs a test suite with a given name and a list of tests. It also supports optional before and after thunks.

```APIDOC
## make-test-suite

### Description
Constructs a test suite with the given name containing the given tests. Unlike the test-suite form, the tests are represented as a list of test values. It also supports optional before and after thunks.

### Syntax
```
(make-test-suite name tests [#:before before-thunk] [#:after after-thunk])
```

### Parameters
- `name`: A string representing the name of the test suite.
- `tests`: A list of test cases or test suites.
- `#:before before-thunk`: An optional thunk to run before the tests.
- `#:after after-thunk`: An optional thunk to run after the tests.

### Returns
- `test-suite?`: A test suite object.
```

--------------------------------

### Run RackUnit tests with text UI

Source: https://docs.racket-lang.org/rackunit/quick-start.html

Imports the `rackunit/text-ui` module and uses `run-tests` to execute a defined test suite. This provides a basic textual output of test results.

```racket
(require rackunit/text-ui)  
(run-tests file-tests)
```

--------------------------------

### Run a Test Case or Suite

Source: https://docs.racket-lang.org/rackunit/internals.html

The `run-test` procedure executes a given test case or test suite, returning a structured tree of results.

```racket
procedure(run-test test)
```

--------------------------------

### Create a RackUnit test case

Source: https://docs.racket-lang.org/rackunit/quick-start.html

Groups multiple checks into a single test case using `test-begin`. This allows for testing multiple properties of a piece of code within one logical unit.

```racket
(test-begin  
  (let ([lst (list 2 4 6 9)])  
    (check = (length lst) 4)
    (for-each  
     (lambda (elt)  
       (check-pred even? elt))
     lst)))
```

--------------------------------

### Define and Use String Info Check

Source: https://docs.racket-lang.org/rackunit/api.html

Demonstrates how to use `string-info` to display a message without quotes in a check failure. This is useful for printing messages instead of raw values.

```racket
(define-check (string-info-check)
  (with-check-info (['value "hello world"]
                    ['message (string-info "hello world")])
    (fail-check)))
(string-info-check)
```

--------------------------------

### Group Expressions with test-begin

Source: https://docs.racket-lang.org/rackunit/api.html

Use `test-begin` to group expressions into a single unit. If any expression within the group fails (raises an exception), the remaining expressions will not be evaluated.

```racket
(test-begin 
---
(check-eq? 'a 'b)
; This line won't be run
(destroy-the-world))
```

--------------------------------

### test-eqv?

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks for eqv? equivalence between two values.

```APIDOC
## test-eqv? name v1 v2

### Description
Creates a test case with the given name that checks if two values are eqv? equivalent.

### Syntax
```
(test-eqv? name v1 v2)
```

### Parameters
- **name** (string?) - The name of the test case.
- **v1** (any/c) - The first value.
- **v2** (any/c) - The second value.
```

--------------------------------

### Implement fold-test-results using foldts-test-suite

Source: https://docs.racket-lang.org/rackunit/internals.html

Shows how `fold-test-results` can be implemented using the more primitive `foldts-test-suite`, illustrating the relationship between the two folding functions.

```racket
(define (fold-test-results suite-fn case-fn seed test)
(foldts-test-suite
(lambda (suite name before after seed)
(before)
(suite-fn name seed))
(lambda (suite name before after seed kid-seed)
(after)
kid-seed)
(lambda (case name action seed)
(case-fn
(run-test-case name action)
seed))
seed
test))
```

--------------------------------

### Shortcut for Equality Test

Source: https://docs.racket-lang.org/rackunit/api.html

The `test-equal?` procedure creates a test case with a given name that performs an equality check. It is a shortcut for `test-case` with `check-equal?`.

```racket
(test-equal? "Fruit test" "apple" "pear")
```

--------------------------------

### check-eq?, check-not-eq?, check-eqv?, check-not-eqv?, check-equal?, check-not-equal?

Source: https://docs.racket-lang.org/rackunit/api.html

These procedures check for equality or inequality between two values using different comparison methods (eq?, eqv?, equal?). An optional message can be provided to be displayed if the check fails.

```APIDOC
## check-eq?, check-not-eq?, check-eqv?, check-not-eqv?, check-equal?, check-not-equal?

### Description
Checks that v1 is equal (or not equal) to v2, using eq?, eqv?, or equal?, respectively. The optional message is included in the output if the check fails.

### Parameters
- **v1** (any/c) - The first value to compare.
- **v2** (any/c) - The second value to compare.
- **message** (or/c string? #f) - Optional. A message to display if the check fails. Defaults to #f.

### Response
This procedure does not return a value; it signals a failure if the condition is not met.
```

--------------------------------

### require/expose

Source: https://docs.racket-lang.org/rackunit/api.html

Accesses bindings that a module does not provide, useful for testing private functions.

```APIDOC
## require/expose module (id ...)

### Description
Requires `id` from `module` into the current module. It doesn’t matter if the source module provides the bindings or not; require/expose can still get at them.

### Note
`require/expose` can be a bit fragile, especially when mixed with compiled code. Use at your own risk!

### Example
```racket
(require/expose rackunit/private/check-test (make-failure-test))
```
```

--------------------------------

### User Interfaces

Source: https://docs.racket-lang.org/rackunit/api.html

Provides interfaces for running tests, including both textual and graphical options.

```APIDOC
## User Interfaces

### Description
Provides interfaces for running tests.

### Textual User Interface
- `run-tests`

### Graphical User Interface
- `test/gui`
- `make-gui-runner`
```

--------------------------------

### Using with-check-info* to add check failure information

Source: https://docs.racket-lang.org/rackunit/api.html

Use `with-check-info*` to push information onto the check-info stack for the duration of a thunk's execution. This information will be displayed if a check fails within the thunk.

```racket
(with-check-info*
 (list (make-check-info 'time (current-seconds)))
 (lambda () (check = 1 2)))
```

--------------------------------

### Use Dynamic Info with Nested Info

Source: https://docs.racket-lang.org/rackunit/api.html

Demonstrates nesting `dynamic-info` within other special formatting wrappers like `nested-info`. The procedure within `dynamic-info` is called, and its result is then rendered according to its own type (e.g., as a nested structure).

```racket
(define current-foo (make-parameter #f))
(with-check-info (['foo (dynamic-info current-foo)])
  (check-equal? 1 2)
  (parameterize ([current-foo
                    (nested-info (list (make-check-info 'nested 'foo)))])
    (check-equal? 1 2)))
```

--------------------------------

### with-check-info*

Source: https://docs.racket-lang.org/rackunit/api.html

Pushes the given info on the check-info stack for the duration (the dynamic extent) of the execution of thunk.

```APIDOC
## procedure(with-check-info* info thunk) → any

### Description
Pushes the given info on the check-info stack for the duration (the dynamic extent) of the execution of thunk.

### Parameters
#### Path Parameters
- **info** (listof check-info?) - Required - Information to push onto the stack.
- **thunk** (-> any) - Required - The procedure to execute with the augmented info.

### Request Example
```racket
(with-check-info* 
  (list (make-check-info 'time (current-seconds)))
  (lambda () (check = 1 2)))
```

### Response
#### Success Response (any)
Returns the result of the thunk execution.

#### Response Example
```racket
#f ; Example of a failed check returning false
```

#### Failure Example
```racket
FAILURE
time:  1771711193
name:  check
location:  eval:52:0
params:  '(#<procedure:= 1 2)
--------------------
```
```

--------------------------------

### Check Documentation Completeness with check-docs

Source: https://docs.racket-lang.org/rackunit/Testing_Utilities.html

Use `check-docs` to verify that all exports of a given module are documented. It prints errors to the current error port for undocumented exports. The `skip` argument can be used to ignore specific exports.

```Racket
(require rackunit/docs-complete)
```

--------------------------------

### test-begin

Source: https://docs.racket-lang.org/rackunit/api.html

Groups expressions into a single test unit. If any expression fails (raises an exception), the remaining expressions in the group are not evaluated.

```APIDOC
## test-begin expr ...

### Description
Groups expressions into a single test unit. If any expression fails (raises an exception), the remaining expressions in the group are not evaluated.

### Syntax
```
(test-begin expr ...)
```

### Example
```
(test-begin
  (check-eq? 'a 'b)
  ; This line won't be run
  (destroy-the-world))
```
```

--------------------------------

### define/provide-test-suite

Source: https://docs.racket-lang.org/rackunit/api.html

Similar to define-test-suite, but also provides the defined test suite.

```APIDOC
## define/provide-test-suite

### Description
This form is just like define-test-suite, and in addition it provides the test suite.

### Syntax
```
(define/provide-test-suite name test ...)
```

### Parameters
- `name`: The name for the test suite.
- `test`: One or more tests to include in the suite.
```

--------------------------------

### run-test-case

Source: https://docs.racket-lang.org/rackunit/internals.html

Runs a single test case and returns its result.

```APIDOC
## run-test-case

### Description
Runs the given test case, returning a result representing success, failure, or error.

### Parameters
- **name** (string | #f) - Description of the test case name.
- **action** (-> any) - The procedure to execute for the test case.

### Returns
- **test-result** - The result of running the test case.
```

--------------------------------

### Check Equality with eqv?

Source: https://docs.racket-lang.org/rackunit/api.html

Use `check-eqv?` to assert that two values are equivalent, considering both value and type for basic types, and identity for pairs and symbols. This is useful for comparing numbers, characters, and symbols.

```racket
(check-eqv? 1 1.0 "not eqv?")
```

--------------------------------

### Execute Code Before and After Expressions

Source: https://docs.racket-lang.org/rackunit/api.html

Executes `before-expr` upon entering the scope and `after-expr` upon leaving the scope, surrounding `expr-1`, `expr-2`, etc. This is useful for resource management like file operations.

```racket
(around 
 (with-output-to-file "test.dat" 
 (lambda () 
 (write "foo"))) 
 (with-input-from-file "test.dat" 
 (lambda () 
 (check-equal? "foo" (read)))) 
 (delete-file "test.dat"))
```

--------------------------------

### Predefined Check Info Functions

Source: https://docs.racket-lang.org/rackunit/api.html

Lists predefined functions for creating `check-info` structures with common names. These functions help avoid typos and standardize the information added to check failures.

```racket
(make-check-name name)
```

```racket
(make-check-params params)
```

```racket
(make-check-location loc)
```

```racket
(make-check-expression msg)
```

```racket
(make-check-message msg)
```

```racket
(make-check-actual param)
```

--------------------------------

### Predefined Check-Info Creation Functions

Source: https://docs.racket-lang.org/rackunit/api.html

Convenience functions for creating check-info structures with predefined names.

```APIDOC
## procedure(make-check-name name)

### Description
Creates a check-info structure with the name 'name'.

### Parameters
- **name** (string?): The name for the check-info.
```

```APIDOC
## procedure(make-check-params params)

### Description
Creates a check-info structure with the name 'params'.

### Parameters
- **params** (listof any/c): The list of parameters for the check-info.
```

```APIDOC
## procedure(make-check-location loc)

### Description
Creates a check-info structure with the name 'location'.

### Parameters
- **loc** ((list/c any/c (or/c number? #f) (or/c number? #f) (or/c number? #f) (or/c number? #f))): The location information for the check-info.
```

```APIDOC
## procedure(make-check-expression msg)

### Description
Creates a check-info structure with the name 'expression'.

### Parameters
- **msg** (any/c): The expression value for the check-info.
```

```APIDOC
## procedure(make-check-message msg)

### Description
Creates a check-info structure with the name 'message'.

### Parameters
- **msg** (string?): The message string for the check-info.
```

```APIDOC
## procedure(make-check-actual param)

### Description
Creates a check-info structure with the name 'actual'.

### Parameters
- **param** (any/c): The actual value for the check-info.
```

--------------------------------

### run-tests

Source: https://docs.racket-lang.org/rackunit/api.html

Runs a given test or test suite and outputs the results.

```APIDOC
## run-tests test [verbosity] → natural-number/c

### Description
The given `test` is run and the result of running it output to the current-output-port if all tests pass, and to current-error-port when there are test failures. The output is compatible with the (X)Emacs next-error command (as used, for example, by (X)Emacs’s compile function).

### Parameters
* **test** (`(or/c test-case? test-suite?)`) - The test case or test suite to run.
* **verbosity** (`(symbols 'quiet 'normal 'verbose) = 'normal`) - Optional. Controls the level of reporting: 'quiet (only successes, failures, errors), 'normal (suppresses some extraneous check info), or 'verbose (reports all information).
```

--------------------------------

### before

Source: https://docs.racket-lang.org/rackunit/api.html

Executes a given expression before executing other expressions within its scope.

```APIDOC
## before

### Description
Whenever control enters the scope, execute the `before-expr` before executing `expr-1`, `expr-2`, ...

### Syntax
```
(before before-expr expr-1 expr-2 ...)
```

### Parameters
- `before-expr`: An expression to execute before the main expressions.
- `expr-1`, `expr-2`, ...: The main expressions to execute.
```

--------------------------------

### Check Pattern Match (Basic)

Source: https://docs.racket-lang.org/rackunit/api.html

Asserts that a pattern matches a given value. If a predicate is not provided, the check succeeds if the pattern matches.

```racket
(check-match (list 1 2 3) (list _ _ 3))
```

```racket
(check-match (list 1 2 3) (list _ _ 4))
```

--------------------------------

### Execute Code Before Expressions

Source: https://docs.racket-lang.org/rackunit/api.html

Whenever control enters the scope, the `before-expr` is executed before `expr-1`, `expr-2`, etc. This is useful for setting up preconditions.

```racket
(before (display "Setup") (check true))
```

--------------------------------

### Miscellaneous Utilities

Source: https://docs.racket-lang.org/rackunit/api.html

A collection of utility functions for various purposes within RackUnit.

```APIDOC
## Miscellaneous Utilities

### Description
A collection of utility functions for various purposes within RackUnit.

### Utilities
- `require/expose`
- `dynamic-require/expose`
- `check-transformer?`
- `check-transformer-impl-name`
```

--------------------------------

### check-docs

Source: https://docs.racket-lang.org/rackunit/Testing_Utilities.html

Checks if a given module path has all its exports documented. Prints an error message to the current-error-port if documentation is incomplete. Supports skipping specific exports.

```APIDOC
## procedure(check-docs lib [#:skip skip]) → any

### Description
Checks to see if the module path named by lib (e.g. 'racket/list) has documented all of its exports and prints an error message to (current-error-port) if not.
If skip is a regexp, then exporting matching that regexp are ignored. If it is a symbol, then that export is ignored. If it is a list of symbols and regexps, then any exporting matching any of the symbols or regexps are ignored. If it is a function, the function is treated as a predicate and passed each export of the module. If skip is #f, no exports are skipped.

### Parameters
* **lib** (module-path?)
* **skip** ((or/c regexp? symbol? (listof (or/c regexp? symbol?)) (-> symbol? any)) | #f) - Optional. Exports to ignore.

### Changed in version
1.10 of package racket-index: Changed lib to accept any module path.
```

--------------------------------

### Access Private Module Bindings with require/expose

Source: https://docs.racket-lang.org/rackunit/api.html

Use require/expose to access bindings from a module, even if they are not publicly exported. This can be useful for testing private functions. Use with caution as it may be fragile.

```racket
(require/expose rackunit/private/check-test (make-failure-test))
```

--------------------------------

### test-exn

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks if a thunk raises an exception satisfying a predicate.

```APIDOC
## test-exn name pred thunk

### Description
Creates a test case with the given name that checks if a thunk raises an exception satisfying a predicate.

### Syntax
```
(test-exn name pred thunk)
```

### Parameters
- **name** (string?) - The name of the test case.
- **pred** (or/c (-> any/c any/c) regexp?) - The predicate function or regexp to check the exception against.
- **thunk** (-> any) - The thunk to execute.
```

--------------------------------

### test-equal?

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks for equality between two values.

```APIDOC
## test-equal? name v1 v2

### Description
Creates a test case with the given name that checks if two values are equal.

### Syntax
```
(test-equal? name v1 v2)
```

### Parameters
- **name** (string?) - The name of the test case.
- **v1** (any/c) - The first value.
- **v2** (any/c) - The second value.

### Example
```
(test-equal? "Fruit test" "apple" "pear")
```

### Equivalent to
```
(test-case "Fruit test" (check-equal? "apple" "pear"))
```
```

--------------------------------

### run-test

Source: https://docs.racket-lang.org/rackunit/internals.html

Runs a test case or test suite and returns a tree of results.

```APIDOC
## run-test

### Description
Runs the given test (test case or test suite) returning a tree (list of lists) of results.

### Parameters
- **test** (test-case? | test-suite?) - The test case or test suite to run.

### Returns
- (listof (or/c test-result? R)) - A tree of test results.
```

--------------------------------

### Using with-check-info macro for contextual information

Source: https://docs.racket-lang.org/rackunit/api.html

The `with-check-info` macro pushes specified name-value pairs onto the check-info stack during the execution of its body. This is useful for providing context to specific checks.

```racket
(for-each 
 (lambda (elt)
 (with-check-info 
 (('current-element elt))
 (check-pred odd? elt)))
 (list 1 3 5 7 8))
```

--------------------------------

### Check for true, false, or not false conditions

Source: https://docs.racket-lang.org/rackunit/api.html

Use `check-true`, `check-false`, and `check-not-false` to assert the truthiness of a value. An optional message can be provided to explain the assertion if it fails. These checks are fundamental for verifying boolean logic.

```racket
(check-true 1)
```

```racket
(check-false 1)
```

```racket
(check-not-false #f)
```

--------------------------------

### Grouped Tests with Test-Begin in RackUnit

Source: https://docs.racket-lang.org/rackunit/philosophy.html

Use `test-begin` to group expressions when there are dependencies between tests, such as those caused by state. If any expression within the group fails, subsequent expressions in that group are not evaluated.

```racket
(test-begin
 (setup-some-state!)
 (check-equal? (foo! 1) 'expected-value-1)
 (check-equal? (foo! 2) 'expected-value-2))
```

--------------------------------

### Custom Check Failure with Extended Info

Source: https://docs.racket-lang.org/rackunit/api.html

Shows how custom checks can add information to the check-info stack, such as a custom location, when using with-check-info*.

```racket
(with-check-info*
  (list (make-check-location (list 'custom 6 1 #f #f)))
  (λ () (check-equal? 0 1)))
```

--------------------------------

### with-default-check-info*

Source: https://docs.racket-lang.org/rackunit/api.html

Similar to with-check-info*, but ignores elements of info whose name (as determined by check-info-name) matches the name of an element on the current check-info stack.

```APIDOC
## procedure(with-default-check-info* info thunk) → any

### Description
Similar to with-check-info*, but ignores elements of info whose name (as determined by check-info-name) matches the name of an element on the current check-info stack.

### Parameters
#### Path Parameters
- **info** (listof check-info?) - Required - Information to push onto the stack.
- **thunk** (-> any) - Required - The procedure to execute with the augmented info.

### Request Example
```racket
(with-default-check-info*
  (list (make-check-name 'first-name))
  (λ () 
    (with-default-check-info*
      (list (make-check-name 'last-name))
      (λ () 
        (check-true #false)))))
```

### Response
#### Success Response (any)
Returns the result of the thunk execution.

#### Response Example
```racket
#f ; Example of a failed check returning false
```

#### Failure Example
```racket
FAILURE
name:  first-name
location:  eval:54:0
params:  '(#f)
--------------------
```
```

--------------------------------

### Write basic RackUnit checks

Source: https://docs.racket-lang.org/rackunit/quick-start.html

Defines simple equality checks for the my-+ and my-* functions. These are the most basic form of tests in RackUnit.

```racket
(check-equal? (my-+ 1 1) 2 "Simple addition")  
(check-equal? (my-* 1 2) 2 "Simple multiplication")
```

--------------------------------

### Define and Use Nested Info Check

Source: https://docs.racket-lang.org/rackunit/api.html

Illustrates the use of `nested-info` to display a list of `check-info` structures in an indented format. This is helpful for organizing and presenting hierarchical failure information.

```racket
(define-check (nested-info-check)
  (define infos
    (list (make-check-info 'foo "foo") (make-check-info 'bar "bar")))
  (with-check-info (['nested (nested-info infos)]) (fail-check)))
(nested-info-check)
```

--------------------------------

### string-info Wrapper

Source: https://docs.racket-lang.org/rackunit/api.html

A special wrapper around a string for use as a check-info value, which is displayed without quotes.

```APIDOC
## struct| string-info (value)

### Description
A special wrapper around a string for use as a check-info value. When displayed in a check failure message, value is displayed without quotes. Used to print messages instead of writing values.

### Fields
- **value** (string?): The string to display without quotes.
```

--------------------------------

### test-=

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks if two real numbers are approximately equal within a given epsilon.

```APIDOC
## test-= name v1 v2 epsilon

### Description
Creates a test case with the given name that checks if two real numbers are approximately equal within a given epsilon.

### Syntax
```
(test-= name v1 v2 epsilon)
```

### Parameters
- **name** (string?) - The name of the test case.
- **v1** (real?) - The first real number.
- **v2** (real?) - The second real number.
- **epsilon** (real?) - The tolerance for equality.
```

--------------------------------

### dynamic-info Wrapper

Source: https://docs.racket-lang.org/rackunit/api.html

A special wrapper around a procedure that produces a value for a check-info, which is called when displayed.

```APIDOC
## struct| dynamic-info (proc)

### Description
A special wrapper around a procedure that produces a value for a check-info. When a dynamic-info is displayed in a check info stack, proc is called to determine what value to display. The value returned by proc may itself be a special formatting value such as nested-info (or even another dynamic-info), in which case that value is rendered as it would be if it had not been wrapped in dynamic-info.

### Fields
- **proc** (-> any/c): A procedure that returns the value for the check-info.
```

--------------------------------

### Check Pattern Match (with Predicate)

Source: https://docs.racket-lang.org/rackunit/api.html

Asserts that a pattern matches a given value and that an optional predicate, evaluated with bindings from the match, returns #t. This allows for more complex assertions on matched values.

```racket
(check-match (list 1 (list 3)) (list x (list _)) (odd? x))
```

```racket
(check-match 6 x (odd? x))
```

```racket
(check-match (list 1 2) (list x) (odd? x))
```

--------------------------------

### Programmatically Running Tests and Inspecting Results

Source: https://docs.racket-lang.org/rackunit/internals.html

RackUnit provides an API for running tests programmatically, allowing for the creation of custom user interfaces.

```APIDOC
## Result Types

### Type: exn:test

### Type: exn:test:check

### Type: test-result

### Type: test-failure

### Type: test-error

### Type: test-success

## Functions to Run Tests

### Procedure: run-test-case

### Procedure: run-test

### Procedure: fold-test-results

### Procedure: foldts-test-suite
```

--------------------------------

### around

Source: https://docs.racket-lang.org/rackunit/api.html

Executes a given expression before and after other expressions within its scope.

```APIDOC
## around

### Description
Whenever control enters the scope, execute the `before-expr` before executing `expr-1`, `expr-2`, ..., and execute `after-expr` whenever control leaves the scope.

### Syntax
```
(around before-expr expr-1 expr-2 ... after-expr)
```

### Parameters
- `before-expr`: An expression to execute before entering the main expressions.
- `expr-1`, `expr-2`, ...: The main expressions to execute.
- `after-expr`: An expression to execute after leaving the main expressions.

### Example
```racket
(around  
  (with-output-to-file "test.dat"  
    (lambda ()  
      (write "foo")))
  (with-input-from-file "test.dat"  
    (lambda ()  
      (check-equal? "foo" (read))))
  (delete-file "test.dat"))
```
```

--------------------------------

### with-check-info

Source: https://docs.racket-lang.org/rackunit/api.html

The with-check-info macro pushes the given information onto the check-info stack for the duration of the execution of the body expressions.

```APIDOC
## syntax(with-check-info ((name val) ...) body ...)

### Description
The with-check-info macro pushes the given information onto the check-info stack for the duration of the execution of the body expressions. Each name must be a quoted symbol and each val must be a value.

### Parameters
#### Path Parameters
- **(name val)** - Required - A list of quoted symbols and their corresponding values to push onto the stack.
- **body ...** - Required - The expressions to execute with the augmented info.

### Request Example
```racket
(with-check-info 
  (('current-element elt))
  (check-pred odd? elt))
```

### Response
#### Success Response (any)
Returns the result of the body expressions.

#### Response Example
```racket
#f ; Example of a failed check returning false
```

#### Failure Example
```racket
FAILURE
current-element: 8
name:  check-pred
location:  eval:53:0
params:  '(#<procedure:odd?> 8)
--------------------
```
```

--------------------------------

### Check Inequality with not eqv?

Source: https://docs.racket-lang.org/rackunit/api.html

Use `check-not-eqv?` to assert that two values are not equivalent. This is useful for verifying that two values that might be considered equal by `eqv?` are indeed different.

```racket
(check-not-eqv? 1 1 "integers are eqv?")
```

--------------------------------

### check-exn

Source: https://docs.racket-lang.org/rackunit/api.html

Verifies that a given thunk (a procedure of no arguments) raises an exception. It checks if the exception matches a predicate or a regular expression.

```APIDOC
## check-exn

### Description
Checks that thunk raises an exception and that either exn-predicate returns a true value if it is a function, or that it matches the message in the exception if exn-predicate is a regexp. In the latter case, the exception raised must be an exn:fail?. The optional message is included in the output if the check fails. A common error is to use an expression instead of a function of no arguments for thunk. Remember that checks are conceptually functions.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```racket
(check-exn exn:fail? (lambda () (raise (make-exn:fail "Hi there" (current-continuation-marks)))))
(check-exn #rx"[Hh]i there" (lambda () (raise (make-exn:fail "Hi there" (current-continuation-marks)))))
(check-exn exn:fail? (lambda () (error 'hi "there")))
(check-exn exn:fail:contract:divide-by-zero? (lambda () (/ 1 0)))
```

### Response
#### Success Response (200)
None (This is a testing assertion, it does not return a value on success)

#### Response Example
None
```

--------------------------------

### Check for exceptions with predicates or regex

Source: https://docs.racket-lang.org/rackunit/api.html

Use `check-exn` to verify that a given thunk raises an exception. The `exn-predicate` can be a function that checks the exception details or a regular expression to match the exception message. Ensure the expression that might raise an exception is wrapped in a `lambda`.

```racket
(check-exn
 exn:fail?
 (lambda () 
 (raise (make-exn:fail "Hi there" 
 (current-continuation-marks)))))

```

```racket
(check-exn
 #rx"[Hh]i there"
 (lambda () 
 (raise (make-exn:fail "Hi there" 
 (current-continuation-marks)))))

```

```racket
(check-exn
 exn:fail?
 (lambda () 
 (error 'hi "there")))
```

```racket
(check-exn exn:fail:contract:divide-by-zero?
 (lambda () 
 (/ 1 0)))
```

```racket
(check-exn exn:fail:contract:divide-by-zero?
 (lambda () 
 (car #f)))
```

```racket
(check-exn
 #rx"Hello there"
 (lambda () 
 (raise (make-exn:fail "Hi there" 
 (current-continuation-marks)))))

```

```racket
; Forgot to wrap the expression in a thunk. Don't do this!
(check-exn exn:fail?
 (error 'hi "there"))
```

--------------------------------

### after

Source: https://docs.racket-lang.org/rackunit/api.html

Executes a given expression after executing other expressions within its scope, even if an exception occurs.

```APIDOC
## after

### Description
Whenever control exits the scope, execute the `after-expr` after executing `expr-1`, and `expr-2`, ... The `after-expr` is executed even if control exits via an exception or other means.

### Syntax
```
(after expr-1 expr-2 ... after-expr)
```

### Parameters
- `expr-1`, `expr-2`, ...: The main expressions to execute.
- `after-expr`: An expression to execute after the main expressions, even on exceptions.
```

--------------------------------

### Check Equality with equal?

Source: https://docs.racket-lang.org/rackunit/api.html

Use `check-equal?` to assert that two values are structurally equal. This is useful for comparing complex data structures like lists, vectors, and hash tables.

```racket
(check-equal? 1 1.0 "not equal?")
```

```racket
(check-not-equal? (list 1) (list 1) "equal?")
```

```racket
(check-equal? (car #f) (car #f))
```

--------------------------------

### test-true

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks if a value is true.

```APIDOC
## test-true name v

### Description
Creates a test case with the given name that checks if a value is true.

### Syntax
```
(test-true name v)
```

### Parameters
- **name** (string?) - The name of the test case.
- **v** (any/c) - The value to check.
```

--------------------------------

### Define a Binary Custom Check with a Predicate

Source: https://docs.racket-lang.org/rackunit/api.html

Use the first form of define-binary-check with a binary predicate to construct a check. This form adds actual and expected values to the check-info stack.

```racket
(define-binary-check (check-char=? char=? actual expected))
```

--------------------------------

### Define Named Test Cases with test-case

Source: https://docs.racket-lang.org/rackunit/api.html

Use `test-case` to group expressions and associate a name with them. The name will be reported if the test fails. This is similar to `test-begin` but provides better reporting.

```racket
(test-case 
---
"Example test"
(check-eq? 'a 'b)
; This line won't be run
(destroy-the-world))
```

--------------------------------

### test-false

Source: https://docs.racket-lang.org/rackunit/api.html

Creates a test case with a given name that checks if a value is false.

```APIDOC
## test-false name v

### Description
Creates a test case with the given name that checks if a value is false.

### Syntax
```
(test-false name v)
```

### Parameters
- **name** (string?) - The name of the test case.
- **v** (any/c) - The value to check.
```

--------------------------------

### Run a Single Test Case

Source: https://docs.racket-lang.org/rackunit/internals.html

Use `run-test-case` to execute a named test case. It returns a result object indicating success, failure, or error.

```racket
procedure(run-test-case name action) → test-result
```

--------------------------------

### Define a RackUnit test suite

Source: https://docs.racket-lang.org/rackunit/quick-start.html

Organizes multiple tests, including simple checks and named test cases, into a single `test-suite`. Test suites allow for delayed execution and structured test organization.

```racket
(define file-tests  
  (test-suite  
   "Tests for file.rkt"  
   (check-equal? (my-+ 1 1) 2 "Simple addition")  
   (check-equal? (my-* 1 2) 2 "Simple multiplication")  
   (test-case  
    "List has length 4 and all elements even"  
    (let ([lst (list 2 4 6 9)])  
      (check = (length lst) 4)  
      (for-each  
       (lambda (elt)  
         (check-pred even? elt))  
       lst)))))
```
Tokens:
Raw